From 75b5ae052afc3968a06fd18c7b4c640ff8c30009 Mon Sep 17 00:00:00 2001 From: James Bradbury Date: Sat, 24 Aug 2019 09:59:05 +0100 Subject: [PATCH] some template lookups --- .../interfaces/FrameLib-obj-dlookup.json | 488 ++ .../interfaces/FrameLib-obj-jlookup.json | 1578 ++++++ .../interfaces/FrameLib-obj-qlookup.json | 4653 +++++++++++++++++ 3 files changed, 6719 insertions(+) create mode 100644 Current Test Version/FrameLib/interfaces/FrameLib-obj-dlookup.json create mode 100644 Current Test Version/FrameLib/interfaces/FrameLib-obj-jlookup.json create mode 100644 Current Test Version/FrameLib/interfaces/FrameLib-obj-qlookup.json diff --git a/Current Test Version/FrameLib/interfaces/FrameLib-obj-dlookup.json b/Current Test Version/FrameLib/interfaces/FrameLib-obj-dlookup.json new file mode 100644 index 00000000..a718b715 --- /dev/null +++ b/Current Test Version/FrameLib/interfaces/FrameLib-obj-dlookup.json @@ -0,0 +1,488 @@ +{ + "fl.spatial~": { + "digest": "Generates multiplication factors for a number of speakers from an input coordinate triple." + }, + "fl.coordinatesystem~": { + "digest": "Converts vectors of triples between cartesian and polar values." + }, + "fl.unpack~": { + "digest": "Unpacks multi-stream input into individual streams." + }, + "fl.streamid~": { + "digest": "Outputs consecutively numbered stream ids for each stream of a multi-stream connection when triggered." + }, + "fl.pack~": { + "digest": "Packs multiple frame streams into a multi-stream output." + }, + "fl.dispatch~": { + "digest": "Dispatches multiple input frame streams dynamically to multiple outputs. Each output can be independently connected to any one (or none) of a number of incoming input frame streams, or turned off." + }, + "fl.route~": { + "digest": "Routes input frames to one of a number of outputs." + }, + "fl.select~": { + "digest": "Selects between a number of input frame streams." + }, + "fl.timedelta~": { + "digest": "Calculates the time interval between consecutive incoming frames." + }, + "fl.timer~": { + "digest": "Calculates the time elapsed between trigger frame inputs and the subsequent reset frame." + }, + "fl.now~": { + "digest": "Outputs the current time." + }, + "fl.ticks~": { + "digest": "Counts how many frames have passed up to a specified value (0 based).." + }, + "fl.argmin~": { + "digest": "Calculates the index of the minimum value of the input frame." + }, + "fl.sort~": { + "digest": "Sorts an input frame in ascending or descending order.." + }, + "fl.shift~": { + "digest": "Shifts an input frame either with padding, or cyclically." + }, + "fl.standarddeviation~": { + "digest": "Calculates the standard deviation of the input frame." + }, + "fl.geometricmean~": { + "digest": "Calculates the geometric mean of the input frame." + }, + "fl.accumpoint~": { + "digest": "Calculates the point in a vector at which the sum reaches a given percentage of the total sum." + }, + "fl.centroid~": { + "digest": "Calculates the centroid of the input frame." + }, + "fl.medianfilter~": { + "digest": "Median filter an input frame." + }, + "fl.percentile~": { + "digest": "Calculates any percentile (for example the median at 50%) of an input frame." + }, + "fl.kurtosis~": { + "digest": "Calculates the kurtosis of the input frame." + }, + "fl.nonzero~": { + "digest": "Outputs indices that are non-zero." + }, + "fl.vmin~": { + "digest": "Calculates the minimum value of the input frame." + }, + "fl.flatness~": { + "digest": "Calculates the flatness of the input frame." + }, + "fl.skewness~": { + "digest": "Calculates the skewness of the input frame." + }, + "fl.join~": { + "digest": "Concatenates all input frames into a single output frame." + }, + "fl.length~": { + "digest": "Calculates the length of the input frame." + }, + "fl.argmax~": { + "digest": "Calculates the index of the maximum value of the input frame." + }, + "fl.mean~": { + "digest": "Calculates the mean of the input frame." + }, + "fl.rms~": { + "digest": "Calculates the rms of the input frame." + }, + "fl.pad~": { + "digest": "Pads an input frame with a fixed value at either the start the end, or both." + }, + "fl.reverse~": { + "digest": "Reverses the order of a single frame's contents.." + }, + "fl.pattern~": { + "digest": "Splits a frame sequentially into smaller frames based on the trigger input.." + }, + "fl.sum~": { + "digest": "Calculates the sum of the input frame." + }, + "fl.nanfilter~": { + "digest": "Replaces or removes NaNs in a vector." + }, + "fl.vmax~": { + "digest": "Calculates the maximum value of the input frame." + }, + "fl.split~": { + "digest": "Splits input frames into two parts, given a specified split point." + }, + "fl.subframe~": { + "digest": "Output part of an input frame." + }, + "fl.product~": { + "digest": "Calculates the product of the input frame." + }, + "fl.crest~": { + "digest": "Calculates the crest factor of the input frame." + }, + "fl.chop~": { + "digest": "Chops input frames into equally sized output frames." + }, + "fl.peaks~": { + "digest": "Finds peaks in an input frame (spectrum)." + }, + "fl.spread~": { + "digest": "Calculates the spread of the input frame." + }, + "fl.complexminus~": { + "digest": "Subtracts the right complex pair of input frame values from the left complex pair of input frame values." + }, + "fl.complexdivide~": { + "digest": "Divides the left complex pair of input frame values by the right complex pair of input frame values." + }, + "fl.complexmultiply~": { + "digest": "Multiplies complexvalues in the two sets of input frames." + }, + "fl.complexpow~": { + "digest": "Calculates left complex pair of input frame values to the power of right complex pair of input frame values." + }, + "fl.complexplus~": { + "digest": "Adds complex values in the two sets of input frames." + }, + "fl.read~": { + "digest": "Reads from a buffer~ given an input frame of sample positions." + }, + "fl.info~": { + "digest": "Outputs the sample rate, number of channels and size of a buffer (in milliseconds). The size units can be changed.." + }, + "fl.exp2~": { + "digest": "Calculates the exponent base 2 (2 to the power of) of each value in the input frame." + }, + "fl.asinh~": { + "digest": "Calculates the hyperbolic arcsine of each value in the input frame." + }, + "fl.log~": { + "digest": "Calculates the logarithm base e of each value in the input frame." + }, + "fl.erf~": { + "digest": "Calculates the error function of each value in the input frame." + }, + "fl.exp~": { + "digest": "Calculates the exponent base e (e to the power of) of each value in the input frame." + }, + "fl.sin~": { + "digest": "Calculates the sine (for arguments in radians) of each value in the input frame." + }, + "fl.log2~": { + "digest": "Calculates the logarithm base 2 of each value in the input frame." + }, + "fl.asin~": { + "digest": "Calculates the arcsine (in radians) of each value in the input frame." + }, + "fl.acos~": { + "digest": "Calculates the arccosine (in radians) of each value in the input frame." + }, + "fl.cos~": { + "digest": "Calculates the cosine (for arguments in radians) of each value in the input frame." + }, + "fl.sinh~": { + "digest": "Calculates the hyperbolic sine of each value in the input frame." + }, + "fl.floor~": { + "digest": "Calculates the floor value of each value in the input frame." + }, + "fl.trunc~": { + "digest": "Calculates the truncated value of each value in the input frame." + }, + "fl.log10~": { + "digest": "Calculates the logarithm base 10 of each value in the input frame." + }, + "fl.atanh~": { + "digest": "Calculates the hyperbolic arctangent of each value in the input frame." + }, + "fl.sqrt~": { + "digest": "Calculates the square root of each value in the input frame." + }, + "fl.acosh~": { + "digest": "Calculates the hyperbolic arccosine of each value in the input frame." + }, + "fl.tan~": { + "digest": "Calculates the tangent (for arguments in radians) of each value in the input frame." + }, + "fl.not~": { + "digest": "Calculates the logical not of each value in the input frame." + }, + "fl.atan~": { + "digest": "Calculates the arctangent (in radians) of each value in the input frame." + }, + "fl.tanh~": { + "digest": "Calculates the hyperbolic tangent of each value in the input frame." + }, + "fl.erfc~": { + "digest": "Calculates the complimentary error function of each value in the input frame." + }, + "fl.abs~": { + "digest": "Calculates the absolute value of each value in the input frame." + }, + "fl.round~": { + "digest": "Calculates the rounded value of each value in the input frame." + }, + "fl.cbrt~": { + "digest": "Calculates the cube root of each value in the input frame." + }, + "fl.cosh~": { + "digest": "Calculates the hyperbolic cosine of each value in the input frame." + }, + "fl.ceil~": { + "digest": "Calculates the ceiling value of each value in the input frame." + }, + "fl.copysign~": { + "digest": "Outputs a frame with the magnitude values of the left input frame and the sign values of right input frame." + }, + "fl.greaterthaneq~": { + "digest": "Calculates if left input frame values are greater than or equal to right input frame values (output is 1 for true and 0 for false)." + }, + "fl.greaterthan~": { + "digest": "Calculates if left input frame values are greater than right input frame values (output is 1 for true and 0 for false)." + }, + "fl.or~": { + "digest": "Calculates the logical or of the left and right input frame values." + }, + "fl.and~": { + "digest": "Calculates the logical and of the left and right input frame values." + }, + "fl.times~": { + "digest": "Multiplies values in the two input frames." + }, + "fl.divide~": { + "digest": "Divides the left input frame values by the right input frame values." + }, + "fl.minus~": { + "digest": "Subtracts the right input frame values from the left input frame values." + }, + "fl.pow~": { + "digest": "Calculates left input frame values to the power of right input frame values." + }, + "fl.atan2~": { + "digest": "For each pair of input values calculates the arctangent using two arguments (left operand is y, right operand is x)." + }, + "fl.notequals~": { + "digest": "Compares frame values for inequality (output is 1 for true and 0 for false)." + }, + "fl.lessthaneq~": { + "digest": "Calculates if left input frame values are greater than or equal to right input frame values (output is 1 for true and 0 for false)." + }, + "fl.max~": { + "digest": "Calculates the maximums of pairs of values in the two input frames." + }, + "fl.plus~": { + "digest": "Adds values in the two input frames." + }, + "fl.modulo~": { + "digest": "Calculates the left input frame values modulo the right input frame values." + }, + "fl.lessthan~": { + "digest": "Calculates if left input frame values are less than right input frame values (output is 1 for true and 0 for false)." + }, + "fl.diff~": { + "digest": "Calculates the absolute differences between values in the two input frames." + }, + "fl.equals~": { + "digest": "Compares frame values for equality (output is 1 for true and 0 for false)." + }, + "fl.hypot~": { + "digest": "For each pair of input values calculates the hypotenuse of a right-angled triangle with sides of the given lengths." + }, + "fl.min~": { + "digest": "Calculates the minimums of pairs of values in the two input frames." + }, + "fl.uniform~": { + "digest": "Generates frames consisting of a single (uniform) value." + }, + "fl.random~": { + "digest": "Generates frames of linearly distributed random values in the range [0-1]." + }, + "fl.gaussian~": { + "digest": "Generates frames of gaussian distributed random values." + }, + "fl.ramp~": { + "digest": "Generates frames that consist of linear ramps from [0-x]." + }, + "fl.tomax~": { + "digest": "Turn frames into host messages. The maximum length of the output message may be limited by the host environment." + }, + "fl.frommax~": { + "digest": "Turn host messages into frames." + }, + "fl.sink~": { + "digest": "Outputs audio frames to the host environment by pasting them into an overlap-add buffer." + }, + "fl.trace~": { + "digest": "Outputs audio frames (or values from the frame) to the host environment without overlapping, continuing the last value till a new frame arrives." + }, + "fl.source~": { + "digest": "Captures audio from the host environment and outputs the most recent values as frames." + }, + "fl.convolve~": { + "digest": "Convolve two input frames, (using frequency domain processing internally)." + }, + "fl.multitaper~": { + "digest": "Calculates the multitaper power spectrum of a real input using the cosine tapers." + }, + "fl.correlate~": { + "digest": "Calculate the correlation of two input frames, (using frequency domain processing internally)." + }, + "fl.fft~": { + "digest": "Calculate the real Fast Fourier Transform of an input frame." + }, + "fl.ifft~": { + "digest": "Calculate the inverse real Fast Fourier Transform of two input frames (comprising the real and imaginary values)." + }, + "fl.window~": { + "digest": "Multiplies the incoming frame against a specified window." + }, + "fl.store~": { + "digest": "Stores a vector frame in named memory for recall." + }, + "fl.register~": { + "digest": "Store and recall a vector frame locally." + }, + "fl.recall~": { + "digest": "Recall a vector frame from named memory for use." + }, + "fl.ewmsd~": { + "digest": "Calculates a per sample exponentially weighted moving standard deviation." + }, + "fl.timemedian~": { + "digest": "Outputs the median per sample over a given number of frames." + }, + "fl.framedelta~": { + "digest": "Outputs the delta between two consecutive frames." + }, + "fl.lag~": { + "digest": "Outputs vector-type frames with a lag set as an integer number of frames." + }, + "fl.ewma~": { + "digest": "Calculates a per sample exponentially weighted moving average." + }, + "fl.timemean~": { + "digest": "Outputs the mean per sample over a given number of frames." + }, + "fl.timestddev~": { + "digest": "Outputs the standard deviation per sample over a given number of frames." + }, + "fl.perblock~": { + "digest": "Schedules one frame at the start of each of the hosts audio blocks." + }, + "fl.once~": { + "digest": "Schedules one frame at the begining of time, lasting forever." + }, + "fl.audiotrigger~": { + "digest": "Translates non-zero samples into trigger frames." + }, + "fl.future~": { + "digest": "Schedules frames in the future at a specified time." + }, + "fl.interval~": { + "digest": "Schedules frames at regular intervals, which can be adjusted using the interval parameter." + }, + "fl.chain~": { + "digest": "Schedules frames in specified times according to the input frame." + }, + "fl.complexsinh~": { + "digest": "Calculates the hyperbolic sine of each complex value at the inputs." + }, + "fl.complextan~": { + "digest": "Calculates the tangent (for arguments in radians) of each complex value at the inputs." + }, + "fl.poltocar~": { + "digest": "Converts from polar values at the input to cartesian values at output." + }, + "fl.complexcos~": { + "digest": "Calculates the cosine (for arguments in radians) of each complex value at the inputs." + }, + "fl.complexsin~": { + "digest": "Calculates the sine (for arguments in radians) of each complex value at the inputs." + }, + "fl.complexcosh~": { + "digest": "Calculates the hyperbolic cosine of each complex value at the inputs." + }, + "fl.complexlog10~": { + "digest": "Calculates the logarithm base 10 of each complex value at the inputs." + }, + "fl.complextanh~": { + "digest": "Calculates the hyperbolic tangent of each complex value at the inputs." + }, + "fl.complexconj~": { + "digest": "Calculates the complex conjugate of each complex value at the inputs." + }, + "fl.complexexp~": { + "digest": "Calculates the exponent base e (e to the power of) of each complex value at the inputs." + }, + "fl.complexlog~": { + "digest": "Calculates the logarithm base e of each complex value at the inputs." + }, + "fl.complexsqrt~": { + "digest": "Calculates the square root of each complex value at the inputs." + }, + "fl.cartopol~": { + "digest": "Converts from cartesian values at the input to polar values at output." + }, + "fl.wrap~": { + "digest": "Wraps the incoming frame into the range delimited by the low and high parameters.." + }, + "fl.fold~": { + "digest": "Folds the incoming frame into the range delimited by the low and high parameters." + }, + "fl.clip~": { + "digest": "Clips the incoming frame to the range delimited by the low and high parameters.." + }, + "fl.lookup~": { + "digest": "Use one frame as a lookup table for another." + }, + "fl.convert~": { + "digest": "Converts the input vector with the specified conversion." + }, + "fl.constant~": { + "digest": "Outputs the specified useful constant." + }, + "fl.map~": { + "digest": "Maps values in the input via a given scaling to corresponding output values." + }, + "fl.samplerate~": { + "digest": "Convert values based on the sample rate / Output a value based on the sampling rate value." + }, + "fl.onepolezero~": { + "digest": "Filters input frames using a one pole, one zero filter." + }, + "fl.0dfsvf~": { + "digest": "Filters input frames using a zero delay state variable filter." + }, + "fl.resonant~": { + "digest": "Filters input frames using a resonant filter." + }, + "fl.sallenkey~": { + "digest": "Filters input frames using a sallen and key filter." + }, + "fl.onepole~": { + "digest": "Filters input frames using a one pole filter." + }, + "fl.complexexpr~": { + "digest": "Applies a mathematical expression to complex pairs of inputs." + }, + "fl.expr~": { + "digest": "Applies a mathematical expression to the inputs." + }, + "fl.filtertags~": { + "digest": "Filters tagged frames into two parts given a number of tags." + }, + "fl.getparam~": { + "digest": "Retrieves parameter values from a connected object." + }, + "fl.tag~": { + "digest": "Tags vectors with names ready to send to the parameter input of an object, or for routing purposes." + }, + "fl.untag~": { + "digest": "Separates vectors from a tagged frame according to a given set of tags." + }, + "fl.combinetags~": { + "digest": "Combines a number of tagged input frames into a single tagged output frame." + } +} \ No newline at end of file diff --git a/Current Test Version/FrameLib/interfaces/FrameLib-obj-jlookup.json b/Current Test Version/FrameLib/interfaces/FrameLib-obj-jlookup.json new file mode 100644 index 00000000..ce583ac1 --- /dev/null +++ b/Current Test Version/FrameLib/interfaces/FrameLib-obj-jlookup.json @@ -0,0 +1,1578 @@ +{ + "fl.spatial~": { + "0": { + "name": "0. /inputmode [enum]", + "description": "Sets the input coordinate mode.\n\nParameter Options:\n[0] - polar\n[1] - cartesian" + }, + "1": { + "name": "1. /speakers [variable length double array]", + "description": "Sets the speaker positions in polar triples (one triple per speaker)." + }, + "2": { + "name": "2. /weights [variable length double array]", + "description": "Sets the speaker weightings (one value per speaker)." + }, + "3": { + "name": "3. /rolloff [double]", + "description": "Sets the rolloff in dB." + }, + "4": { + "name": "4. /blur [double]", + "description": "Sets the blur factor." + }, + "5": { + "name": "5. /maxspeakers [int]", + "description": "Sets the maximum number of speakers to be used (the neaarest N speakers will be used only). If zero all speakers are used." + }, + "6": { + "name": "6. /points [double]", + "description": "Interpolate to point source panning (0 is modified DBAP - 1 is point source)." + } + }, + "fl.coordinatesystem~": { + "0": { + "name": "0. /mode [instantiation enum]", + "description": "Sets the conversion mode.\n\nParameter Options:\n[0] - polar->cartesian\n[1] - cartesian->polar" + } + }, + "fl.unpack~": { + "0": { + "name": "0. /outputs [instantiation int]", + "description": "Sets the number of outputs." + } + }, + "fl.streamid~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.pack~": { + "0": { + "name": "0. /inputs [instantiation int]", + "description": "Sets the number of inputs." + } + }, + "fl.dispatch~": { + "0": { + "name": "0. /num_ins [instantiation double]", + "description": "Sets the number of inputs." + }, + "1": { + "name": "1. /num_outs [instantiation double]", + "description": "Sets the number of outputs." + }, + "2": { + "name": "2. /input_ 1 [int]", + "description": "" + }, + "3": { + "name": "3. /input_ 2 [int]", + "description": "" + } + }, + "fl.route~": { + "0": { + "name": "0. /num_outs [instantiation double]", + "description": "Sets the number of outputs." + }, + "1": { + "name": "1. /output [int]", + "description": "Sets the current output counting from 1 (off if out of range)." + } + }, + "fl.select~": { + "0": { + "name": "0. /num_ins [instantiation double]", + "description": "Sets the number of inputs." + }, + "1": { + "name": "1. /input [int]", + "description": "Sets the current input counting from 1 (or off if out of range)." + } + }, + "fl.timedelta~": { + "0": { + "name": "0. /units [instantiation enum]", + "description": "Sets the time units used to for output.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.timer~": { + "0": { + "name": "0. /units [instantiation enum]", + "description": "Sets the time units used to for output.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.now~": { + "0": { + "name": "0. /units [instantiation enum]", + "description": "Sets the time units used for output.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.ticks~": { + "0": { + "name": "0. /limit [int]", + "description": "Sets the counter threshold." + }, + "1": { + "name": "1. /value [int]", + "description": "Sets a new starting value at next trigger" + }, + "2": { + "name": "2. /limit_mode [enum]", + "description": "Sets the mode for changes in threshold.\n\nParameter Options:\n[0] - progress\n[1] - restart" + }, + "3": { + "name": "3. /run_mode [enum]", + "description": "Sets the run mode.\n\nParameter Options:\n[0] - run\n[1] - pause\n[2] - stop" + } + }, + "fl.argmin~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.sort~": { + "0": { + "name": "0. /order [enum]", + "description": "Sets the ordering of the sorted output.\n\nParameter Options:\n[0] - up\n[1] - down" + }, + "1": { + "name": "1. /indices_mode [bool]", + "description": "No parameter info available" + } + }, + "fl.shift~": { + "0": { + "name": "0. /shift [double]", + "description": "Sets the shift amount (-ve for left shift / +ve for right shift)." + }, + "1": { + "name": "1. /pad [double]", + "description": "Sets the padding value." + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the shift mode. pad - values are replaced with the padding value. wrap - values are wrapped cyclically.\n\nParameter Options:\n[0] - pad\n[1] - wrap" + }, + "3": { + "name": "3. /units [enum]", + "description": "Sets units for the shift (samples or ratio of the input length [-1 to 1]).\n\nParameter Options:\n[0] - samples\n[1] - ratios" + } + }, + "fl.standarddeviation~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.geometricmean~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.accumpoint~": { + "0": { + "name": "0. /percentage [double]", + "description": "Sets the percentile of the accumlation for the calculation [0-100]." + } + }, + "fl.centroid~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.medianfilter~": { + "0": { + "name": "0. /width [int]", + "description": "Sets the width of the median filtering in samples." + }, + "1": { + "name": "1. /pad [double]", + "description": "Sets the padding value." + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the mode that controls the edge behaviour: pad - the edges are treated as though infinitely padded with the padding value. wrap - the edges are treated as though the frame is wrapped cyclically. fold - the edges are treated as though they fold over (suitable for spectral purposes).\n\nParameter Options:\n[0] - pad\n[1] - wrap\n[2] - fold" + } + }, + "fl.percentile~": { + "0": { + "name": "0. /percentile [double]", + "description": "Sets the percentile to calculate [0-100]." + } + }, + "fl.kurtosis~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.nonzero~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.vmin~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.flatness~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.skewness~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.join~": { + "0": { + "name": "0. /num_ins [instantiation int]", + "description": "Sets the number of inputs." + }, + "1": { + "name": "1. /trigger_ins [instantiation fixed length bool array]", + "description": "Set which inputs trigger output (by default all inputs)." + } + }, + "fl.length~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.argmax~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.mean~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.rms~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.pad~": { + "0": { + "name": "0. /pad [double]", + "description": "Sets the padding value." + }, + "1": { + "name": "1. /start [double]", + "description": "Sets the amount of padding to apply at the start of the frame." + }, + "2": { + "name": "2. /end [double]", + "description": "Sets the amount of padding to apply at the end of the frame." + }, + "3": { + "name": "3. /units [enum]", + "description": "Sets units for padding amounts (samples or ratios [0-1]).\n\nParameter Options:\n[0] - samples\n[1] - ratios" + } + }, + "fl.reverse~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.pattern~": { + "0": { + "name": "0. /mode [enum]", + "description": "Set the playback mode. once - the pattern is played once only. loop - the pattern loops infinitely.\n\nParameter Options:\n[0] - once\n[1] - loop" + } + }, + "fl.sum~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.nanfilter~": { + "0": { + "name": "0. /mode [enum]", + "description": "Set whether to replace or remove NaN values\n\nParameter Options:\n[0] - replace\n[1] - remove" + }, + "1": { + "name": "1. /value [double]", + "description": "Set the value with which to replace NaN values" + } + }, + "fl.vmax~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.split~": { + "0": { + "name": "0. /split [double]", + "description": "Sets the split point." + }, + "1": { + "name": "1. /units [enum]", + "description": "Sets units for the split point (samples or ratios [0-1]).\n\nParameter Options:\n[0] - samples\n[1] - ratios" + } + }, + "fl.subframe~": { + "0": { + "name": "0. /start [double]", + "description": "Sets the start point of the subframe." + }, + "1": { + "name": "1. /end [double]", + "description": "Sets the end point of the subframe." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets units for the start and end points (samples or ratios [0-1]).\n\nParameter Options:\n[0] - samples\n[1] - ratios" + } + }, + "fl.product~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.crest~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.chop~": { + "0": { + "name": "0. /num_outs [instantiation int]", + "description": "Sets the number of outputs." + }, + "1": { + "name": "1. /size [double]", + "description": "Sets the size of the output frames." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets units for the chop size (samples or ratio of the input length [0-1]).\n\nParameter Options:\n[0] - samples\n[1] - ratios" + } + }, + "fl.peaks~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.spread~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexminus~": { + "0": { + "name": "0. /mismatch [enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [fixed length double array]", + "description": "Sets the complex value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.complexdivide~": { + "0": { + "name": "0. /mismatch [enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [fixed length double array]", + "description": "Sets the complex value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.complexmultiply~": { + "0": { + "name": "0. /mismatch [enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [fixed length double array]", + "description": "Sets the complex value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.complexpow~": { + "0": { + "name": "0. /mismatch [enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [fixed length double array]", + "description": "Sets the complex value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.complexplus~": { + "0": { + "name": "0. /mismatch [enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [fixed length double array]", + "description": "Sets the complex value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.read~": { + "0": { + "name": "0. /buffer [string]", + "description": "Sets the buffer~ name to use." + }, + "1": { + "name": "1. /chan [int]", + "description": "Sets the buffer~ channel to use." + }, + "2": { + "name": "2. /interp [enum]", + "description": "Sets the interpolation mode: hermite - cubic hermite interpolation. bspline - cubic bspline interpolation. lagrange - cubic lagrange interpolation. linear - linear interpolation.\n\nParameter Options:\n[0] - hermite\n[1] - bspline\n[2] - lagrange\n[3] - linear\n[4] - none" + }, + "3": { + "name": "3. /units [enum]", + "description": "Sets the units for the position input.\n\nParameter Options:\n[0] - ms\n[1] - seconds\n[2] - samples" + } + }, + "fl.info~": { + "0": { + "name": "0. /buffer [string]", + "description": "Sets the buffer name to use." + }, + "1": { + "name": "1. /units [enum]", + "description": "Sets the units of output for the size of the buffer.\n\nParameter Options:\n[0] - ms\n[1] - seconds\n[2] - samples" + } + }, + "fl.exp2~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.asinh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.log~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.erf~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.exp~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.sin~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.log2~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.asin~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.acos~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.cos~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.sinh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.floor~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.trunc~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.log10~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.atanh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.sqrt~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.acosh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.tan~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.not~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.atan~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.tanh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.erfc~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.abs~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.round~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.cbrt~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.cosh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.ceil~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.copysign~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.greaterthaneq~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.greaterthan~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.or~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.and~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.times~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.divide~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.minus~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.pow~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.atan2~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.notequals~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.lessthaneq~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.max~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.plus~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.modulo~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.lessthan~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.diff~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.equals~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.hypot~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.min~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - the smaller input is read modulo against the larger input. shrink - the output length is set to the size of the smaller input. pad_in - the smaller input is padded prior to calculation to match the size of the larger input. pad_out - the output is padded to match the size of the larger input.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - pad_in\n[3] - pad_out" + }, + "1": { + "name": "1. /trigger_ins [instantiation enum]", + "description": "Sets which inputs trigger output.\n\nParameter Options:\n[0] - both\n[1] - left\n[2] - right" + }, + "2": { + "name": "2. /pad [instantiation double]", + "description": "Sets the value used for padding (for either pad_in or pad_out modes)." + } + }, + "fl.uniform~": { + "0": { + "name": "0. /value [double]", + "description": "Sets the value to repeat for each output frame." + }, + "1": { + "name": "1. /mode [enum]", + "description": "Controls how the output length is determined: requested - the output frame size is set by the length parameter. input - the output frame size will match the input size.\n\nParameter Options:\n[0] - requested\n[1] - input" + }, + "2": { + "name": "2. /length [int]", + "description": "Sets the length of the output when the mode is set to requested. Set in the units specified by the units parameter." + }, + "3": { + "name": "3. /units [enum]", + "description": "Sets the units for specified output lengths.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.random~": { + "0": { + "name": "0. /mode [enum]", + "description": "Controls how the output length is determined: requested - the output frame size is set by the length parameter. input - the output frame size will match the input size.\n\nParameter Options:\n[0] - requested\n[1] - input" + }, + "1": { + "name": "1. /length [int]", + "description": "Sets the length of the output when the mode is set to requested. Set in the units specified by the units parameter." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets the units for specified output lengths.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.gaussian~": { + "0": { + "name": "0. /mode [enum]", + "description": "Controls how the output length is determined: requested - the output frame size is set by the length parameter. input - the output frame size will match the input size.\n\nParameter Options:\n[0] - requested\n[1] - input" + }, + "1": { + "name": "1. /length [int]", + "description": "Sets the length of the output when the mode is set to requested. Set in the units specified by the units parameter." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets the units for specified output lengths.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + } + }, + "fl.ramp~": { + "0": { + "name": "0. /mode [enum]", + "description": "Controls how the output length is determined: requested - the output frame size is set by the length parameter. input - the output frame size will match the input size.\n\nParameter Options:\n[0] - requested\n[1] - input" + }, + "1": { + "name": "1. /length [int]", + "description": "Sets the length of the output when the mode is set to requested. Set in the units specified by the units parameter." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets the units for specified output lengths.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "3": { + "name": "3. /scale [enum]", + "description": "Sets the scaling of the output ramp.\n\nParameter Options:\n[0] - count\n[1] - ms\n[2] - seconds\n[3] - normalised" + } + }, + "fl.tomax~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.frommax~": { + "0": { + "name": "0. /mode [enum]", + "description": "Sets the object mode. values - translate values from max into vectors. params - translate messages into concatenated tagged frames to set parameters\n\nParameter Options:\n[0] - values\n[1] - params" + } + }, + "fl.sink~": { + "0": { + "name": "0. /buffer_size [instantiation double]", + "description": "Sets the internal buffer size in the units specified by the units parameter." + }, + "1": { + "name": "1. /units [instantiation enum]", + "description": "Sets the time units used to determine the buffer size and delay.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "2": { + "name": "2. /delay [double]", + "description": "Sets the delay before output in the units specified by the units parameter." + } + }, + "fl.trace~": { + "0": { + "name": "0. /mode [enum]", + "description": "Sets the mode used for output: full - outputs the entire frame in full. first - output the first sample of the frame only. last - output the last sample of the frame only. specified - output the sample specified directly by the position parameter (clipped into the frame size). ratio - output the sample specified by the position parameter as a ratio to the frame length (clipped into the frame size).\n\nParameter Options:\n[0] - full\n[1] - first\n[2] - last\n[3] - specified\n[4] - ratio" + }, + "1": { + "name": "1. /buffer_size [instantiation double]", + "description": "Sets the internal buffer size in the units specified by the units parameter." + }, + "2": { + "name": "2. /units [instantiation enum]", + "description": "Sets the time units used to determine the buffer size and delay.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "3": { + "name": "3. /position [double]", + "description": "Sets the position of the output sample in specified mode (in samples) or ratio mode (as a ratio of the position in the frame)." + }, + "4": { + "name": "4. /delay [double]", + "description": "Sets the delay before output in the units specified by the units parameter." + } + }, + "fl.source~": { + "0": { + "name": "0. /buffer_size [instantiation double]", + "description": "Sets the internal buffer size in the units specified by the units parameter." + }, + "1": { + "name": "1. /length [int]", + "description": "Sets the length of output frames in the units specified by the units parameter." + }, + "2": { + "name": "2. /units [enum]", + "description": "Sets the time units used to determine the buffer size and output length.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "3": { + "name": "3. /delay [double]", + "description": "Sets the input delay in the units specified by the units parameter: N.B. - there is a minimum delay or latency of the output length." + } + }, + "fl.convolve~": { + "0": { + "name": "0. /maxlength [instantiation int]", + "description": "Sets the maximum output length. The output length will be M + N - 1 where M and N are the sizes of the two inputs respectively" + }, + "1": { + "name": "1. /mode [instantiation enum]", + "description": "Sets the type of input expected / output produced.\n\nParameter Options:\n[0] - real\n[1] - complex" + }, + "2": { + "name": "2. /edges [instantiation enum]", + "description": "No parameter info available\n\nParameter Options:\n[0] - linear\n[1] - circular\n[2] - wrap\n[3] - fold" + } + }, + "fl.multitaper~": { + "0": { + "name": "0. /maxlength [instantiation int]", + "description": "Sets the maximum input length / FFT size." + }, + "1": { + "name": "1. /numtapers [int]", + "description": "Sets the number of tapers to use." + } + }, + "fl.correlate~": { + "0": { + "name": "0. /maxlength [instantiation int]", + "description": "Sets the maximum output length. The output length will be M + N - 1 where M and N are the sizes of the two inputs respectively" + }, + "1": { + "name": "1. /mode [instantiation enum]", + "description": "Sets the type of input expected / output produced.\n\nParameter Options:\n[0] - real\n[1] - complex" + }, + "2": { + "name": "2. /edges [instantiation enum]", + "description": "No parameter info available\n\nParameter Options:\n[0] - linear\n[1] - circular\n[2] - wrap\n[3] - fold" + } + }, + "fl.fft~": { + "0": { + "name": "0. /maxlength [instantiation int]", + "description": "Sets the maximum input length / FFT size." + }, + "1": { + "name": "1. /normalise [instantiation bool]", + "description": "When on the output is normalised so that sine waves produce the same level output regardless of the FFT size." + }, + "2": { + "name": "2. /mode [instantiation enum]", + "description": "Sets the type of input expected / output produced.\n\nParameter Options:\n[0] - real\n[1] - complex\n[2] - fullspectrum" + } + }, + "fl.ifft~": { + "0": { + "name": "0. /maxlength [instantiation int]", + "description": "Sets the maximum output length / FFT size." + }, + "1": { + "name": "1. /normalise [instantiation bool]", + "description": "When on the input is expected to be normalised." + }, + "2": { + "name": "2. /mode [instantiation enum]", + "description": "Sets the type of input expected / output produced.\n\nParameter Options:\n[0] - real\n[1] - complex\n[2] - fullspectrum" + } + }, + "fl.window~": { + "0": { + "name": "0. /window [enum]", + "description": "Sets the window type.\n\nParameter Options:\n[0] - hann\n[1] - hamming\n[2] - triangle\n[3] - cosine\n[4] - blackman\n[5] - blackman62\n[6] - blackman70\n[7] - blackman74\n[8] - blackman92\n[9] - blackmanharris\n[10] - flattop\n[11] - rectangle" + }, + "1": { + "name": "1. /size [double]", + "description": "Sets the size of the internal window. If set to 0 the window will be recalculated to match the input size (good for frequency domain applications. Otherwise an internally stored window is linearly interpolated to fit the input size (good for granular applications." + }, + "2": { + "name": "2. /sqrt [bool]", + "description": "Sets whether the window should be used directly, or the square root of the window." + }, + "3": { + "name": "3. /compensate [enum]", + "description": "Sets the gain compensation used. off - no compensation is used. linear - compensate the linear gain of the window. power - compensate the power gain of the window. powoverlin - compensate by the power gain divided by the linear gain\n\nParameter Options:\n[0] - off\n[1] - linear\n[2] - power\n[3] - powoverlin" + }, + "4": { + "name": "4. /endpoints [enum]", + "description": "Sets which endpoints of the window used will be non-zero for windows that start and end at zero.\n\nParameter Options:\n[0] - first\n[1] - last\n[2] - both\n[3] - none" + } + }, + "fl.store~": { + "0": { + "name": "0. /name [instantiation string]", + "description": "Sets the name of the memory location to use." + } + }, + "fl.register~": { + "0": { + "name": "0. /mode [instantiation enum]", + "description": "Sets the behaviour of the right input: store - stores without output. pass - stores and outputs.\n\nParameter Options:\n[0] - store\n[1] - pass" + } + }, + "fl.recall~": { + "0": { + "name": "0. /name [instantiation string]", + "description": "Sets the name of the memory location to use." + } + }, + "fl.ewmsd~": { + "0": { + "name": "0. /alpha_up [double]", + "description": "Sets the alpha value for weighting when the input is increasing." + }, + "1": { + "name": "1. /alpha_down [double]", + "description": "Sets the alpha value for weighting when the input is decreasing." + } + }, + "fl.timemedian~": { + "0": { + "name": "0. /max_frames [int]", + "description": "Sets the maximum number of frames that can be set as a time period - changing resets the buffer." + }, + "1": { + "name": "1. /num_frames [int]", + "description": "Sets the current integer number of frames for calculation." + } + }, + "fl.framedelta~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.lag~": { + "0": { + "name": "0. /max_frames [int]", + "description": "Sets the maximum number of frames that can be set as a lag time." + }, + "1": { + "name": "1. /num_frames [int]", + "description": "Sets the current lag as an integer number of frames." + } + }, + "fl.ewma~": { + "0": { + "name": "0. /alpha_up [double]", + "description": "Sets the alpha value for weighting when the input is increasing." + }, + "1": { + "name": "1. /alpha_down [double]", + "description": "Sets the alpha value for weighting when the input is decreasing." + } + }, + "fl.timemean~": { + "0": { + "name": "0. /max_frames [int]", + "description": "Sets the maximum number of frames that can be set as a time period - changing resets the buffer." + }, + "1": { + "name": "1. /num_frames [int]", + "description": "Sets the current integer number of frames for calculation." + } + }, + "fl.timestddev~": { + "0": { + "name": "0. /max_frames [int]", + "description": "Sets the maximum number of frames that can be set as a time period - changing resets the buffer." + }, + "1": { + "name": "1. /num_frames [int]", + "description": "Sets the current integer number of frames for calculation." + } + }, + "fl.perblock~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.once~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.audiotrigger~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.future~": { + "0": { + "name": "0. /time [double]", + "description": "Sets the time of the next frame." + }, + "1": { + "name": "1. /units [enum]", + "description": "Sets the time units.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the mode for timings (relative or absolute)\n\nParameter Options:\n[0] - absolute\n[1] - relative" + } + }, + "fl.interval~": { + "0": { + "name": "0. /interval [double]", + "description": "Sets the interval between frames in the units of the units parameter." + }, + "1": { + "name": "1. /units [enum]", + "description": "Sets the time units used to set the interval between frames.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds\n[3] - hz" + } + }, + "fl.chain~": { + "0": { + "name": "0. /units [enum]", + "description": "Sets the time units used.\n\nParameter Options:\n[0] - samples\n[1] - ms\n[2] - seconds" + }, + "1": { + "name": "1. /mode [enum]", + "description": "Sets the mode for timings (absolute or relative)\n\nParameter Options:\n[0] - absolute\n[1] - relative" + } + }, + "fl.complexsinh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complextan~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.poltocar~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexcos~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexsin~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexcosh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexlog10~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complextanh~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexconj~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexexp~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexlog~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.complexsqrt~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.cartopol~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.wrap~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - smaller right inputs are read modulo against larger left input. shrink - the output length is set to the size of the smaller input. extend - smaller right inputs are extended by repeating their final value\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - extend" + } + }, + "fl.fold~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - smaller right inputs are read modulo against larger left input. shrink - the output length is set to the size of the smaller input. extend - smaller right inputs are extended by repeating their final value\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - extend" + } + }, + "fl.clip~": { + "0": { + "name": "0. /mismatch [instantiation enum]", + "description": "Sets the mode used when dealing with mismatched input lengths: wrap - smaller right inputs are read modulo against larger left input. shrink - the output length is set to the size of the smaller input. extend - smaller right inputs are extended by repeating their final value\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - extend" + } + }, + "fl.lookup~": { + "0": { + "name": "0. /mode [enum]", + "description": "No parameter info available\n\nParameter Options:\n[0] - zero\n[1] - clip" + }, + "1": { + "name": "1. /interp [enum]", + "description": "No parameter info available\n\nParameter Options:\n[0] - hermite\n[1] - bspline\n[2] - lagrange\n[3] - linear\n[4] - none" + }, + "2": { + "name": "2. /scale [enum]", + "description": "No parameter info available\n\nParameter Options:\n[0] - samples\n[1] - normalised\n[2] - bipolar" + } + }, + "fl.convert~": { + "0": { + "name": "0. /mode [enum]", + "description": "Sets the mode of conversion: db->amp - converts from decibels into linear amplitudes. amp->db - converts from linear amplitudes int decibels. midi->freq - converts from midi notes into frequencies. freq->mid - converts from frequencies into midi notes. semitone->ratio - converts semitone transpositons into ratios. ratio->semitone - converts from transpositon ratios in semitones. deg->rad - converts from degress to radians. rad->deg - converts from radians to degrees.\n\nParameter Options:\n[0] - db->amp\n[1] - amp->db\n[2] - midi->freq\n[3] - freq->midi\n[4] - semitone->ratio\n[5] - ratio->semitone\n[6] - deg->rad\n[7] - rad->deg" + } + }, + "fl.constant~": { + "0": { + "name": "0. /constant [enum]", + "description": "Sets the constant to output.\n\nParameter Options:\n[0] - pi\n[1] - e\n[2] - sqrt2\n[3] - 1/pi\n[4] - 1/e\n[5] - 1/sqrt2\n[6] - epsilon" + }, + "1": { + "name": "1. /multiplier [double]", + "description": "Sets the multiplier." + } + }, + "fl.map~": { + "0": { + "name": "0. /mode [enum]", + "description": "Sets the type of output scaling: linear / log / exp - scaling as specified. pow - scale the input range to [0-1], apply the specifiedexponent and then scale to the output range. db / invdb - output / input respectively are set in dB but scaled as gain values. transpose / invtranspose - output / input respectively are set in semitones but scaled as ratios for transposition.\n\nParameter Options:\n[0] - linear\n[1] - log\n[2] - exp\n[3] - pow\n[4] - db\n[5] - invdb\n[6] - transpose\n[7] - invtranspose" + }, + "1": { + "name": "1. /inlo [double]", + "description": "Sets the low input value." + }, + "2": { + "name": "2. /inhi [double]", + "description": "Sets the high input value." + }, + "3": { + "name": "3. /outlo [double]", + "description": "Sets the low output value." + }, + "4": { + "name": "4. /outhi [double]", + "description": "Sets the high output value." + }, + "5": { + "name": "5. /exponent [double]", + "description": "Sets the exponent for the pow mode." + }, + "6": { + "name": "6. /clip [bool]", + "description": "If true then the output is clipped between the low and high output value." + } + }, + "fl.samplerate~": { + "0": { + "name": "0. /mode [instantiation enum]", + "description": "Sets the type of conversion / value to output: value - output the sample rate. nyquist - output the nyquist frequency. samples->ms - convert from samples to milliseconds. samples->seconds - convert from samples to seconds. ms->samples - convert from milliseconds to samples. seconds->samples - convert from seconds to samples. norm->freq - convert from normalised frequency [0 - 1 is 0 - sample rate] to frequency in Hz. halfnorm->freq - convert from half normalised frequency [0 - 1 is 0 - nyquist] to frequency in Hz. freq->norm - convert from frequency in Hz to normalised frequency [0 - 1 is 0 - sample rate]. freq->halfnorm - convert from frequency in Hz to hald normalised frequency [0 - 1 is 0 - nyquist].\n\nParameter Options:\n[0] - value\n[1] - nyquist\n[2] - samples->ms\n[3] - samples->seconds\n[4] - ms->samples\n[5] - seconds->samples\n[6] - norm->freq\n[7] - halfnorm->freq\n[8] - freq->norm\n[9] - freq->halfnorm" + } + }, + "fl.onepolezero~": { + "0": { + "name": "0. /freq [double]", + "description": "Sets the filter cutoff frequency." + }, + "1": { + "name": "1. /mode [enum]", + "description": "Sets the filter mode.\n\nParameter Options:\n[0] - lpf\n[1] - hpf" + } + }, + "fl.0dfsvf~": { + "0": { + "name": "0. /freq [double]", + "description": "Sets the filter cutoff frequency." + }, + "1": { + "name": "1. /reson [double]", + "description": "Sets the filter resonance [0-1]." + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the filter mode.\n\nParameter Options:\n[0] - lpf\n[1] - bpf\n[2] - hpf" + } + }, + "fl.resonant~": { + "0": { + "name": "0. /freq [double]", + "description": "Sets the filter cutoff frequency." + }, + "1": { + "name": "1. /reson [double]", + "description": "Sets the filter resonance [0-1]." + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the filter mode.\n\nParameter Options:\n[0] - lpf\n[1] - hpf" + } + }, + "fl.sallenkey~": { + "0": { + "name": "0. /freq [double]", + "description": "Sets the filter cutoff frequency." + }, + "1": { + "name": "1. /reson [double]", + "description": "Sets the filter resonance [0-1]." + }, + "2": { + "name": "2. /mode [enum]", + "description": "Sets the filter mode.\n\nParameter Options:\n[0] - lpf\n[1] - bpf\n[2] - hpf" + } + }, + "fl.onepole~": { + "0": { + "name": "0. /freq [double]", + "description": "Sets the filter cutoff frequency." + }, + "1": { + "name": "1. /mode [enum]", + "description": "Sets the filter mode.\n\nParameter Options:\n[0] - lpf\n[1] - hpf" + } + }, + "fl.complexexpr~": { + "0": { + "name": "0. /expr [instantiation string]", + "description": "Sets the mathematical expression." + }, + "1": { + "name": "1. /mismatch [instantiation enum]", + "description": "Sets the number of inputs.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - extend" + }, + "2": { + "name": "2. /trigger_ins [instantiation variable length bool array]", + "description": "No parameter info available" + } + }, + "fl.expr~": { + "0": { + "name": "0. /expr [instantiation string]", + "description": "Sets the mathematical expression." + }, + "1": { + "name": "1. /mismatch [instantiation enum]", + "description": "Sets the number of inputs.\n\nParameter Options:\n[0] - wrap\n[1] - shrink\n[2] - extend" + }, + "2": { + "name": "2. /trigger_ins [instantiation variable length bool array]", + "description": "No parameter info available" + } + }, + "fl.filtertags~": { + "0": { + "name": "0. /num_filters [instantiation int]", + "description": "Sets the number of parameter names." + }, + "1": { + "name": "1. /tag_01 [instantiation string]", + "description": "No parameter info available" + } + }, + "fl.getparam~": { + "0": { + "name": null, + "description": "This object has no parameters." + } + }, + "fl.tag~": { + "0": { + "name": "0. /num_ins [instantiation int]", + "description": "Sets the number of inputs (and hence the number of tags)." + }, + "1": { + "name": "1. /empty_mode [instantiation enum]", + "description": "Sets the behaviour when empty frames are received: ignore - empty frames are ignored / reset - empty frames create empty tags to reset parameters.\n\nParameter Options:\n[0] - ignore\n[1] - reset" + }, + "2": { + "name": "2. /tag_01 [instantiation string]", + "description": "Sets the tag for input 1." + } + }, + "fl.untag~": { + "0": { + "name": "0. /num_outs [instantiation int]", + "description": "Sets the number of outputs (and hence the number of tags." + }, + "1": { + "name": "1. /tag_01 [instantiation string]", + "description": "Sets the tag related to output 1." + } + }, + "fl.combinetags~": { + "0": { + "name": "0. /num_ins [instantiation int]", + "description": "Sets the number of inputs." + } + } +} \ No newline at end of file diff --git a/Current Test Version/FrameLib/interfaces/FrameLib-obj-qlookup.json b/Current Test Version/FrameLib/interfaces/FrameLib-obj-qlookup.json new file mode 100644 index 00000000..41b0a579 --- /dev/null +++ b/Current Test Version/FrameLib/interfaces/FrameLib-obj-qlookup.json @@ -0,0 +1,4653 @@ +{ + "fl.spatial~": { + "digest": "Generates multiplication factors for a number of speakers from an input coordinate triple.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spatial" + ], + "keywords": [ + "spatialiastion" + ], + "seealso": [ + "fl.coordinatesystem~" + ] + }, + "fl.coordinatesystem~": { + "digest": "Converts vectors of triples between cartesian and polar values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spatial" + ], + "keywords": [ + "spatialiastion" + ], + "seealso": [ + "fl.spatial~" + ] + }, + "fl.unpack~": { + "digest": "Unpacks multi-stream input into individual streams.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Streaming" + ], + "keywords": [ + "multistreaming", + "streams" + ], + "seealso": [ + "fl.pack~", + "fl.streamid~" + ] + }, + "fl.streamid~": { + "digest": "Outputs consecutively numbered stream ids for each stream of a multi-stream connection when triggered.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Streaming" + ], + "keywords": [ + "multistreaming", + "streams" + ], + "seealso": [ + "fl.pack~", + "fl.unpack~" + ] + }, + "fl.pack~": { + "digest": "Packs multiple frame streams into a multi-stream output.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Streaming" + ], + "keywords": [ + "multistreaming", + "streams" + ], + "seealso": [ + "fl.unpack~", + "fl.streamid~" + ] + }, + "fl.dispatch~": { + "digest": "Dispatches multiple input frame streams dynamically to multiple outputs. Each output can be independently connected to any one (or none) of a number of incoming input frame streams, or turned off.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Routing" + ], + "keywords": [ + "routing" + ], + "seealso": [ + "fl.route~", + "fl.select~" + ] + }, + "fl.route~": { + "digest": "Routes input frames to one of a number of outputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Routing" + ], + "keywords": [ + "routing" + ], + "seealso": [ + "fl.dispatch~", + "fl.select~" + ] + }, + "fl.select~": { + "digest": "Selects between a number of input frame streams.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Routing" + ], + "keywords": [ + "routing" + ], + "seealso": [ + "fl.dispatch~", + "fl.route~" + ] + }, + "fl.timedelta~": { + "digest": "Calculates the time interval between consecutive incoming frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Timing" + ], + "keywords": [ + "timing" + ], + "seealso": [ + "fl.now~", + "fl.timer~", + "fl.ticks~" + ] + }, + "fl.timer~": { + "digest": "Calculates the time elapsed between trigger frame inputs and the subsequent reset frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Timing" + ], + "keywords": [ + "timing" + ], + "seealso": [ + "fl.timedelta~", + "fl.now~", + "fl.ticks~" + ] + }, + "fl.now~": { + "digest": "Outputs the current time.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Timing" + ], + "keywords": [ + "timing" + ], + "seealso": [ + "fl.timedelta~", + "fl.timer~", + "fl.ticks~" + ] + }, + "fl.ticks~": { + "digest": "Counts how many frames have passed up to a specified value (0 based)..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Timing" + ], + "keywords": [ + "timing" + ], + "seealso": [ + "fl.timedelta~", + "fl.now~", + "fl.timer~" + ] + }, + "fl.argmin~": { + "digest": "Calculates the index of the minimum value of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.sort~": { + "digest": "Sorts an input frame in ascending or descending order..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.shift~": { + "digest": "Shifts an input frame either with padding, or cyclically.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.standarddeviation~": { + "digest": "Calculates the standard deviation of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.geometricmean~": { + "digest": "Calculates the geometric mean of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.accumpoint~": { + "digest": "Calculates the point in a vector at which the sum reaches a given percentage of the total sum.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.centroid~": { + "digest": "Calculates the centroid of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.medianfilter~": { + "digest": "Median filter an input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~" + ] + }, + "fl.percentile~": { + "digest": "Calculates any percentile (for example the median at 50%) of an input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.kurtosis~": { + "digest": "Calculates the kurtosis of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.nonzero~": { + "digest": "Outputs indices that are non-zero.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.vmin~": { + "digest": "Calculates the minimum value of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.flatness~": { + "digest": "Calculates the flatness of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.skewness~": { + "digest": "Calculates the skewness of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.join~": { + "digest": "Concatenates all input frames into a single output frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.length~": { + "digest": "Calculates the length of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.argmax~": { + "digest": "Calculates the index of the maximum value of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.mean~": { + "digest": "Calculates the mean of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.rms~": { + "digest": "Calculates the rms of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.pad~": { + "digest": "Pads an input frame with a fixed value at either the start the end, or both.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.reverse~": { + "digest": "Reverses the order of a single frame's contents..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.pattern~": { + "digest": "Splits a frame sequentially into smaller frames based on the trigger input..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.sum~": { + "digest": "Calculates the sum of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.nanfilter~": { + "digest": "Replaces or removes NaNs in a vector.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.vmax~": { + "digest": "Calculates the maximum value of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.split~": { + "digest": "Splits input frames into two parts, given a specified split point.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.medianfilter~" + ] + }, + "fl.subframe~": { + "digest": "Output part of an input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.product~": { + "digest": "Calculates the product of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.crest~": { + "digest": "Calculates the crest factor of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.chop~": { + "digest": "Chops input frames into equally sized output frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.peaks~": { + "digest": "Finds peaks in an input frame (spectrum).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.spread~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.spread~": { + "digest": "Calculates the spread of the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Vector" + ], + "keywords": [ + "vector" + ], + "seealso": [ + "fl.argmin~", + "fl.percentile~", + "fl.standarddeviation~", + "fl.centroid~", + "fl.accumpoint~", + "fl.nonzero~", + "fl.argmax~", + "fl.geometricmean~", + "fl.vmax~", + "fl.kurtosis~", + "fl.sort~", + "fl.mean~", + "fl.join~", + "fl.shift~", + "fl.vmin~", + "fl.sum~", + "fl.subframe~", + "fl.nanfilter~", + "fl.reverse~", + "fl.length~", + "fl.peaks~", + "fl.pattern~", + "fl.product~", + "fl.skewness~", + "fl.crest~", + "fl.pad~", + "fl.chop~", + "fl.flatness~", + "fl.rms~", + "fl.split~", + "fl.medianfilter~" + ] + }, + "fl.complexminus~": { + "digest": "Subtracts the right complex pair of input frame values from the left complex pair of input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Binary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexpow~", + "fl.complexplus~", + "fl.complexdivide~", + "fl.complexmultiply~" + ] + }, + "fl.complexdivide~": { + "digest": "Divides the left complex pair of input frame values by the right complex pair of input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Binary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexpow~", + "fl.complexminus~", + "fl.complexplus~", + "fl.complexmultiply~" + ] + }, + "fl.complexmultiply~": { + "digest": "Multiplies complexvalues in the two sets of input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Binary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexpow~", + "fl.complexminus~", + "fl.complexplus~", + "fl.complexdivide~" + ] + }, + "fl.complexpow~": { + "digest": "Calculates left complex pair of input frame values to the power of right complex pair of input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Binary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexminus~", + "fl.complexplus~", + "fl.complexdivide~", + "fl.complexmultiply~" + ] + }, + "fl.complexplus~": { + "digest": "Adds complex values in the two sets of input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Binary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexpow~", + "fl.complexminus~", + "fl.complexdivide~", + "fl.complexmultiply~" + ] + }, + "fl.read~": { + "digest": "Reads from a buffer~ given an input frame of sample positions.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Buffer" + ], + "keywords": [ + "buffer" + ], + "seealso": [ + "fl.info~", + "ibuffer" + ] + }, + "fl.info~": { + "digest": "Outputs the sample rate, number of channels and size of a buffer (in milliseconds). The size units can be changed..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Buffer" + ], + "keywords": [ + "buffer" + ], + "seealso": [ + "fl.read~", + "ibuffer" + ] + }, + "fl.exp2~": { + "digest": "Calculates the exponent base 2 (2 to the power of) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.asinh~": { + "digest": "Calculates the hyperbolic arcsine of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.log~": { + "digest": "Calculates the logarithm base e of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.erf~": { + "digest": "Calculates the error function of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.exp~": { + "digest": "Calculates the exponent base e (e to the power of) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.sin~": { + "digest": "Calculates the sine (for arguments in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~" + ] + }, + "fl.log2~": { + "digest": "Calculates the logarithm base 2 of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.asin~": { + "digest": "Calculates the arcsine (in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.acos~": { + "digest": "Calculates the arccosine (in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.cos~": { + "digest": "Calculates the cosine (for arguments in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.sinh~": { + "digest": "Calculates the hyperbolic sine of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.floor~": { + "digest": "Calculates the floor value of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.trunc~": { + "digest": "Calculates the truncated value of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.log10~": { + "digest": "Calculates the logarithm base 10 of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.atanh~": { + "digest": "Calculates the hyperbolic arctangent of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.sqrt~": { + "digest": "Calculates the square root of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.acosh~": { + "digest": "Calculates the hyperbolic arccosine of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.tan~": { + "digest": "Calculates the tangent (for arguments in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.sin~" + ] + }, + "fl.not~": { + "digest": "Calculates the logical not of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.atan~": { + "digest": "Calculates the arctangent (in radians) of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.tanh~": { + "digest": "Calculates the hyperbolic tangent of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.erfc~": { + "digest": "Calculates the complimentary error function of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.abs~": { + "digest": "Calculates the absolute value of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.round~": { + "digest": "Calculates the rounded value of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.cbrt~": { + "digest": "Calculates the cube root of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.cosh~": { + "digest": "Calculates the hyperbolic cosine of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.ceil~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.ceil~": { + "digest": "Calculates the ceiling value of each value in the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Unary" + ], + "keywords": [ + "unary ops", + "operators" + ], + "seealso": [ + "fl.sqrt~", + "fl.floor~", + "fl.exp2~", + "fl.tanh~", + "fl.cbrt~", + "fl.cos~", + "fl.atanh~", + "fl.acosh~", + "fl.atan~", + "fl.erf~", + "fl.cosh~", + "fl.asin~", + "fl.exp~", + "fl.log10~", + "fl.log2~", + "fl.erfc~", + "fl.acos~", + "fl.abs~", + "fl.log~", + "fl.asinh~", + "fl.trunc~", + "fl.not~", + "fl.sinh~", + "fl.round~", + "fl.tan~", + "fl.sin~" + ] + }, + "fl.copysign~": { + "digest": "Outputs a frame with the magnitude values of the left input frame and the sign values of right input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.greaterthaneq~": { + "digest": "Calculates if left input frame values are greater than or equal to right input frame values (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.modulo~" + ] + }, + "fl.greaterthan~": { + "digest": "Calculates if left input frame values are greater than right input frame values (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.or~": { + "digest": "Calculates the logical or of the left and right input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.and~": { + "digest": "Calculates the logical and of the left and right input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.times~": { + "digest": "Multiplies values in the two input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.divide~": { + "digest": "Divides the left input frame values by the right input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.minus~": { + "digest": "Subtracts the right input frame values from the left input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.pow~": { + "digest": "Calculates left input frame values to the power of right input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.atan2~": { + "digest": "For each pair of input values calculates the arctangent using two arguments (left operand is y, right operand is x).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.notequals~": { + "digest": "Compares frame values for inequality (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.lessthaneq~": { + "digest": "Calculates if left input frame values are greater than or equal to right input frame values (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.max~": { + "digest": "Calculates the maximums of pairs of values in the two input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.plus~": { + "digest": "Adds values in the two input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.modulo~": { + "digest": "Calculates the left input frame values modulo the right input frame values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~" + ] + }, + "fl.lessthan~": { + "digest": "Calculates if left input frame values are less than right input frame values (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.diff~": { + "digest": "Calculates the absolute differences between values in the two input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.equals~": { + "digest": "Compares frame values for equality (output is 1 for true and 0 for false).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.hypot~": { + "digest": "For each pair of input values calculates the hypotenuse of a right-angled triangle with sides of the given lengths.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.min~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.min~": { + "digest": "Calculates the minimums of pairs of values in the two input frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Binary" + ], + "keywords": [ + "binary ops, operators" + ], + "seealso": [ + "fl.lessthan~", + "fl.atan2~", + "fl.minus~", + "fl.hypot~", + "fl.equals~", + "fl.times~", + "fl.pow~", + "fl.divide~", + "fl.max~", + "fl.notequals~", + "fl.greaterthan~", + "fl.and~", + "fl.lessthaneq~", + "fl.diff~", + "fl.plus~", + "fl.or~", + "fl.copysign~", + "fl.greaterthaneq~", + "fl.modulo~" + ] + }, + "fl.uniform~": { + "digest": "Generates frames consisting of a single (uniform) value.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Generators" + ], + "keywords": [ + "generators" + ], + "seealso": [ + "fl.random~", + "fl.gaussian~", + "fl.ramp~" + ] + }, + "fl.random~": { + "digest": "Generates frames of linearly distributed random values in the range [0-1].", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Generators" + ], + "keywords": [ + "generators" + ], + "seealso": [ + "fl.gaussian~", + "fl.uniform~", + "fl.ramp~" + ] + }, + "fl.gaussian~": { + "digest": "Generates frames of gaussian distributed random values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Generators" + ], + "keywords": [ + "generators" + ], + "seealso": [ + "fl.random~", + "fl.uniform~", + "fl.ramp~" + ] + }, + "fl.ramp~": { + "digest": "Generates frames that consist of linear ramps from [0-x].", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Generators" + ], + "keywords": [ + "generators" + ], + "seealso": [ + "fl.random~", + "fl.gaussian~", + "fl.uniform~" + ] + }, + "fl.tomax~": { + "digest": "Turn frames into host messages. The maximum length of the output message may be limited by the host environment.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Host_Communication" + ], + "keywords": [ + "conversion" + ], + "seealso": [ + "fl.frommax~" + ] + }, + "fl.frommax~": { + "digest": "Turn host messages into frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Host_Communication" + ], + "keywords": [ + "conversion" + ], + "seealso": [ + "fl.tomax~" + ] + }, + "fl.sink~": { + "digest": "Outputs audio frames to the host environment by pasting them into an overlap-add buffer.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib IO" + ], + "keywords": [ + "conversion" + ], + "seealso": [ + "fl.source~", + "fl.trace~" + ] + }, + "fl.trace~": { + "digest": "Outputs audio frames (or values from the frame) to the host environment without overlapping, continuing the last value till a new frame arrives.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib IO" + ], + "keywords": [ + "conversion" + ], + "seealso": [ + "fl.source~", + "fl.sink~" + ] + }, + "fl.source~": { + "digest": "Captures audio from the host environment and outputs the most recent values as frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib IO" + ], + "keywords": [ + "conversion" + ], + "seealso": [ + "fl.trace~", + "fl.sink~" + ] + }, + "fl.convolve~": { + "digest": "Convolve two input frames, (using frequency domain processing internally).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.fft~", + "fl.multitaper~", + "fl.ifft~", + "fl.correlate~", + "fl.window~" + ] + }, + "fl.multitaper~": { + "digest": "Calculates the multitaper power spectrum of a real input using the cosine tapers.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.fft~", + "fl.convolve~", + "fl.ifft~", + "fl.correlate~", + "fl.window~" + ] + }, + "fl.correlate~": { + "digest": "Calculate the correlation of two input frames, (using frequency domain processing internally).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.fft~", + "fl.multitaper~", + "fl.convolve~", + "fl.ifft~", + "fl.window~" + ] + }, + "fl.fft~": { + "digest": "Calculate the real Fast Fourier Transform of an input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.multitaper~", + "fl.convolve~", + "fl.ifft~", + "fl.correlate~", + "fl.window~" + ] + }, + "fl.ifft~": { + "digest": "Calculate the inverse real Fast Fourier Transform of two input frames (comprising the real and imaginary values).", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.fft~", + "fl.multitaper~", + "fl.convolve~", + "fl.correlate~", + "fl.window~" + ] + }, + "fl.window~": { + "digest": "Multiplies the incoming frame against a specified window.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Spectral" + ], + "keywords": [ + "FFT, windowing, frequency domain" + ], + "seealso": [ + "fl.fft~", + "fl.multitaper~", + "fl.convolve~", + "fl.ifft~", + "fl.correlate~" + ] + }, + "fl.store~": { + "digest": "Stores a vector frame in named memory for recall.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Storage" + ], + "keywords": [ + "storage" + ], + "seealso": [ + "fl.register~", + "fl.recall~" + ] + }, + "fl.register~": { + "digest": "Store and recall a vector frame locally.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Storage" + ], + "keywords": [ + "storage" + ], + "seealso": [ + "fl.store~", + "fl.recall~" + ] + }, + "fl.recall~": { + "digest": "Recall a vector frame from named memory for use.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Storage" + ], + "keywords": [ + "storage" + ], + "seealso": [ + "fl.store~", + "fl.register~" + ] + }, + "fl.ewmsd~": { + "digest": "Calculates a per sample exponentially weighted moving standard deviation.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.ewma~", + "fl.timemedian~", + "fl.lag~", + "fl.framedelta~", + "fl.timemean~" + ] + }, + "fl.timemedian~": { + "digest": "Outputs the median per sample over a given number of frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.ewma~", + "fl.lag~", + "fl.ewmsd~", + "fl.framedelta~", + "fl.timemean~" + ] + }, + "fl.framedelta~": { + "digest": "Outputs the delta between two consecutive frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.ewma~", + "fl.timemedian~", + "fl.lag~", + "fl.ewmsd~", + "fl.timemean~" + ] + }, + "fl.lag~": { + "digest": "Outputs vector-type frames with a lag set as an integer number of frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.ewma~", + "fl.timemedian~", + "fl.ewmsd~", + "fl.framedelta~", + "fl.timemean~" + ] + }, + "fl.ewma~": { + "digest": "Calculates a per sample exponentially weighted moving average.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.timemedian~", + "fl.lag~", + "fl.ewmsd~", + "fl.framedelta~", + "fl.timemean~" + ] + }, + "fl.timemean~": { + "digest": "Outputs the mean per sample over a given number of frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.timestddev~", + "fl.ewma~", + "fl.timemedian~", + "fl.lag~", + "fl.ewmsd~", + "fl.framedelta~" + ] + }, + "fl.timestddev~": { + "digest": "Outputs the standard deviation per sample over a given number of frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Time_Smoothing" + ], + "keywords": [ + "time smoothing", + "statistics" + ], + "seealso": [ + "fl.ewma~", + "fl.timemedian~", + "fl.lag~", + "fl.ewmsd~", + "fl.framedelta~", + "fl.timemean~" + ] + }, + "fl.perblock~": { + "digest": "Schedules one frame at the start of each of the hosts audio blocks.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.interval~", + "fl.audiotrigger~", + "fl.once~", + "fl.chain~", + "fl.future~" + ] + }, + "fl.once~": { + "digest": "Schedules one frame at the begining of time, lasting forever.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.interval~", + "fl.perblock~", + "fl.audiotrigger~", + "fl.chain~", + "fl.future~" + ] + }, + "fl.audiotrigger~": { + "digest": "Translates non-zero samples into trigger frames.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.interval~", + "fl.perblock~", + "fl.once~", + "fl.chain~", + "fl.future~" + ] + }, + "fl.future~": { + "digest": "Schedules frames in the future at a specified time.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.interval~", + "fl.perblock~", + "fl.audiotrigger~", + "fl.once~", + "fl.chain~" + ] + }, + "fl.interval~": { + "digest": "Schedules frames at regular intervals, which can be adjusted using the interval parameter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.perblock~", + "fl.audiotrigger~", + "fl.once~", + "fl.chain~", + "fl.future~" + ] + }, + "fl.chain~": { + "digest": "Schedules frames in specified times according to the input frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Schedulers" + ], + "keywords": [ + "timing, schedulers", + "triggers" + ], + "seealso": [ + "fl.interval~", + "fl.perblock~", + "fl.audiotrigger~", + "fl.once~", + "fl.future~" + ] + }, + "fl.complexsinh~": { + "digest": "Calculates the hyperbolic sine of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complextan~": { + "digest": "Calculates the tangent (for arguments in radians) of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.poltocar~": { + "digest": "Converts from polar values at the input to cartesian values at output.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~" + ] + }, + "fl.complexcos~": { + "digest": "Calculates the cosine (for arguments in radians) of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexsin~": { + "digest": "Calculates the sine (for arguments in radians) of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexcosh~": { + "digest": "Calculates the hyperbolic cosine of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexlog10~": { + "digest": "Calculates the logarithm base 10 of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complextanh~": { + "digest": "Calculates the hyperbolic tangent of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexconj~": { + "digest": "Calculates the complex conjugate of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexexp~": { + "digest": "Calculates the exponent base e (e to the power of) of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexlog~": { + "digest": "Calculates the logarithm base e of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.complexsqrt~": { + "digest": "Calculates the square root of each complex value at the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.cartopol~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.poltocar~" + ] + }, + "fl.cartopol~": { + "digest": "Converts from cartesian values at the input to polar values at output.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Complex_Unary" + ], + "keywords": [ + "complex numbers", + "complex operators" + ], + "seealso": [ + "fl.complexcos~", + "fl.complexlog10~", + "fl.complexsinh~", + "fl.complexconj~", + "fl.complexexp~", + "fl.complexlog~", + "fl.complexcosh~", + "fl.complextan~", + "fl.complexsin~", + "fl.complextanh~", + "fl.complexsqrt~", + "fl.poltocar~" + ] + }, + "fl.wrap~": { + "digest": "Wraps the incoming frame into the range delimited by the low and high parameters..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Ternary" + ], + "keywords": [ + "ternary ops", + "operators" + ], + "seealso": [ + "fl.clip~", + "fl.fold~" + ] + }, + "fl.fold~": { + "digest": "Folds the incoming frame into the range delimited by the low and high parameters.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Ternary" + ], + "keywords": [ + "ternary ops", + "operators" + ], + "seealso": [ + "fl.wrap~", + "fl.clip~" + ] + }, + "fl.clip~": { + "digest": "Clips the incoming frame to the range delimited by the low and high parameters..", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Ternary" + ], + "keywords": [ + "ternary ops", + "operators" + ], + "seealso": [ + "fl.wrap~", + "fl.fold~" + ] + }, + "fl.lookup~": { + "digest": "Use one frame as a lookup table for another.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Mapping" + ], + "keywords": [ + "scaling", + "mapping" + ], + "seealso": [ + "fl.convert~", + "fl.map~", + "fl.constant~", + "fl.samplerate~" + ] + }, + "fl.convert~": { + "digest": "Converts the input vector with the specified conversion.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Mapping" + ], + "keywords": [ + "scaling", + "mapping" + ], + "seealso": [ + "fl.map~", + "fl.constant~", + "fl.samplerate~", + "fl.lookup~" + ] + }, + "fl.constant~": { + "digest": "Outputs the specified useful constant.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Mapping" + ], + "keywords": [ + "scaling", + "mapping" + ], + "seealso": [ + "fl.convert~", + "fl.map~", + "fl.samplerate~", + "fl.lookup~" + ] + }, + "fl.map~": { + "digest": "Maps values in the input via a given scaling to corresponding output values.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Mapping" + ], + "keywords": [ + "scaling", + "mapping" + ], + "seealso": [ + "fl.convert~", + "fl.constant~", + "fl.samplerate~", + "fl.lookup~" + ] + }, + "fl.samplerate~": { + "digest": "Convert values based on the sample rate / Output a value based on the sampling rate value.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Mapping" + ], + "keywords": [ + "scaling", + "mapping" + ], + "seealso": [ + "fl.convert~", + "fl.map~", + "fl.constant~", + "fl.lookup~" + ] + }, + "fl.onepolezero~": { + "digest": "Filters input frames using a one pole, one zero filter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Filters" + ], + "keywords": [ + "filters" + ], + "seealso": [ + "fl.resonant~", + "fl.0dfsvf~", + "fl.sallenkey~", + "fl.onepole~" + ] + }, + "fl.0dfsvf~": { + "digest": "Filters input frames using a zero delay state variable filter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Filters" + ], + "keywords": [ + "filters" + ], + "seealso": [ + "fl.resonant~", + "fl.sallenkey~", + "fl.onepolezero~", + "fl.onepole~" + ] + }, + "fl.resonant~": { + "digest": "Filters input frames using a resonant filter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Filters" + ], + "keywords": [ + "filters" + ], + "seealso": [ + "fl.0dfsvf~", + "fl.sallenkey~", + "fl.onepolezero~", + "fl.onepole~" + ] + }, + "fl.sallenkey~": { + "digest": "Filters input frames using a sallen and key filter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Filters" + ], + "keywords": [ + "filters" + ], + "seealso": [ + "fl.resonant~", + "fl.0dfsvf~", + "fl.onepolezero~", + "fl.onepole~" + ] + }, + "fl.onepole~": { + "digest": "Filters input frames using a one pole filter.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Filters" + ], + "keywords": [ + "filters" + ], + "seealso": [ + "fl.resonant~", + "fl.0dfsvf~", + "fl.sallenkey~", + "fl.onepolezero~" + ] + }, + "fl.complexexpr~": { + "digest": "Applies a mathematical expression to complex pairs of inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Expressions" + ], + "keywords": [ + "expression" + ], + "seealso": [ + "fl.expr~" + ] + }, + "fl.expr~": { + "digest": "Applies a mathematical expression to the inputs.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Expressions" + ], + "keywords": [ + "expression" + ], + "seealso": [ + "fl.complexexpr~" + ] + }, + "fl.filtertags~": { + "digest": "Filters tagged frames into two parts given a number of tags.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Parameters" + ], + "keywords": [ + "parameters" + ], + "seealso": [ + "fl.tag~", + "fl.untag~", + "fl.combinetags~", + "fl.getparam~" + ] + }, + "fl.getparam~": { + "digest": "Retrieves parameter values from a connected object.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Parameters" + ], + "keywords": [ + "parameters" + ], + "seealso": [ + "fl.tag~", + "fl.untag~", + "fl.combinetags~", + "fl.filtertags~" + ] + }, + "fl.tag~": { + "digest": "Tags vectors with names ready to send to the parameter input of an object, or for routing purposes.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Parameters" + ], + "keywords": [ + "parameters" + ], + "seealso": [ + "fl.untag~", + "fl.combinetags~", + "fl.getparam~", + "fl.filtertags~" + ] + }, + "fl.untag~": { + "digest": "Separates vectors from a tagged frame according to a given set of tags.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Parameters" + ], + "keywords": [ + "parameters" + ], + "seealso": [ + "fl.tag~", + "fl.combinetags~", + "fl.getparam~", + "fl.filtertags~" + ] + }, + "fl.combinetags~": { + "digest": "Combines a number of tagged input frames into a single tagged output frame.", + "module": "FrameLib", + "category": [ + "FrameLib", + "FrameLib Parameters" + ], + "keywords": [ + "parameters" + ], + "seealso": [ + "fl.tag~", + "fl.untag~", + "fl.getparam~", + "fl.filtertags~" + ] + } +} \ No newline at end of file