Skip to content

Math

  • mtx_pow mtx_pow calculates the power function for each element of a matrix, performing element-wise matrix arithmetic.
  • conv.dbfs2amp~ conv.dbfs2amp~ converts a decibel full-scale (dBFS) input signal to an amplitude output signal.
  • linterp~ linterp~ performs linear interpolation.
  • fd_circle fd_circle computes successive positions for circular motion, outputting each position as an x–y list and supporting use with Gem.
  • minimum The minimum object outputs the smallest value from its inputs.
  • list.mean list.mean calculates the arithmetic average of a list of floats and outputs the result as a float.
  • phon2db The phon2db object converts a loudness value expressed in phons to decibels (dB).
  • sh~ The sh~ object performs sample-and-hold on an audio signal, effectively downsampling it.
  • quadratic quadratic curves an input range using a quadratic Bézier, producing a mapped output in the range 0 to 1.
  • mtx_meshgrid mtx_meshgrid creates X and Y grid matrices from x- and y-tick vectors, producing all (x, y) value pairs.
  • list.correlate list.correlate calculates the cross-correlation of two lists and outputs the resulting list, with modes full, same, and valid.
  • curve_exp curve_exp maps a float input range to an exponential curve, with an output range from 0 to 1.
  • array.p2s array.p2s converts a phase value in the range 0–1 into a sample position for a named array, enabling relative access to that array.
  • matrix.max matrix.max returns the maximum element in a matrix as a float.
  • matrix_mul_line~ matrix_mul_line~ multiplies a vector of input signals by a dynamically changeable matrix, producing an output-signal vector (SIG_OUT = A * SIG_IN).
  • sph2cart The sph2cart object converts spherical coordinates (radius, azimuth, elevation) to Cartesian coordinates (x, y, z).
  • polarizer polarizer is a simple signal polarizer/attenuverter that can attenuate or invert its input and add a DC offset.
  • matrix.add matrix.add performs element-wise matrix addition and outputs the resulting Matrix.
  • autotune2 The autotune2 object quantizes incoming pitch values, expressed in cents, to the closest step within a user-defined scale.
  • Lround Lround rounds a float or the floats in a list.
  • math.erf math.erf computes the error function, a mathematical function associated with Gaussian statistics.
  • mtx_max2 mtx_max2 computes the element-wise maximum of two matrices, serving as the matrix equivalent of max.
  • mtx_sub mtx_sub performs matrix arithmetic subtraction, either subtracting one matrix from another or subtracting an offset from a matrix.
  • cartopol~ The cartopol~ object converts a signal from Cartesian coordinates (real and imaginary parts) to polar coordinates (amplitude and phase).
  • gendyn~ The gendyn~ object implements Dynamic Stochastic Synthesis, generating waveforms where each point's amplitude and frequency evolve via a random walk.
  • scalarmult The scalarmult object performs scalar multiplication, also known as a "dot product," on incoming lists of numbers.
  • vectorabs vectorabs takes a vector—a list of numbers—and outputs a new vector containing the elementwise absolute values.
  • math.sin math.sin computes the sine of an input value.
  • matrix.linspace matrix.linspace generates a one-row matrix containing N linearly spaced values from a start value through an included end value.
  • list-exec list-exec computes a specified function on every element of an input list.
  • vstd vstd computes the standard deviation of a vector supplied as a list of float values.
  • lavg lavg computes a leaky average of incoming floats and outputs the averaged value.
  • math.exp~ math.exp~ computes the base-e exponential of each value in an input signal and outputs the resulting signal.
  • math.sync_mul math.sync_mul performs synchronized multiplication, outputting the result whenever either the multiplier or multiplicand is changed.
  • catch_extremum2 catch_extremum2 returns the most recent local minimum and maximum from its input data.
  • tab_abs tab_abs copies the absolute values of samples from a source array to a destination array when it receives a bang.
  • exp_inc exp_inc is a bang-controlled counter that increments its value linearly using an absolute increment and/or exponentially using a relative percentage, within specified minimum and maximum values.
  • mtx_diag mtx_diag creates a diagonal matrix and can also extract the diagonal of an input matrix.
  • dbtoamp~ dbtoamp~ converts dB-FS decibel values into amplitude values.
  • array.s2p array.s2p converts sample positions into relative positions for a named array, nominally in the phase range 0–1.
  • median The median object calculates the median value of a given list of numbers.
  • math.acosh math.acosh computes the principal value of the inverse hyperbolic cosine for an input value.
  • fd_sum fd_sum accumulates incoming float values and outputs the running sum, making it useful for totaling a stream of numbers.
  • pix_threshold_bernsen pix_threshold_bernsen applies a dynamic tiled threshold filter to greyscale images for binarization.
  • samps2ms~ The samps2ms~ object converts a time value given in samples to milliseconds.
  • balance~ The balance~ object performs equal power (sin/cos) stereo balancing.
  • frac.mul The frac.mul object multiplies two fractional values.
  • lattice3 lattice3 expands a three-dimensional harmonic lattice vector in the basis (2, 3/2, 5/4).
  • curve_gaussian curve_gaussian maps an input range to an output between 0 and 1.
  • tab+ tab+ provides a short way to increment values in a Pd table.
  • iAmbient2D The iAmbient2D object simulates ambient interactions in a 2D space, applying constant, random, and damping forces to named "masses." It also handles displacement if a mass moves outside a defined rectangular area.
  • three_d three_d calculates a three-dimensional attractor, outputting X, Y, and Z values when driven periodically, such as by metro.
  • standard~ The standard~ object is a chaotic signal generator based on the standard map equation.
  • mavg The mavg object implements a moving average filter, smoothing incoming float values by averaging a specified number of recent samples.
  • tdh.util.counter tdh.util.counter counts the number of incoming messages, regardless of message type.
  • roundIfVeryClose roundIfVeryClose rounds a float to the nearest integer when its difference from that integer is below a configurable threshold, making it useful for cleaning up numbers shown in displays.
  • midi2mapping midi2mapping is a control-rate conversion abstraction with one float inlet and one float outlet.
  • cartopol The cartopol~ object converts Cartesian coordinates (real and imaginary parts) from signal inputs into polar coordinates (amplitude and phase) as signal outputs.
  • fd_sinc~ fd_sinc~ generates the same sinc table as fd_sinc, but stores it into an array using DSP; it is used by fd_windows.
  • db2v db2v converts an input level in decibels (dB) to a unitless output value.
  • sph2pol The sph2pol object converts spherical coordinates (radius R, azimuthal angle phi, and polar angle theta) into polar coordinates.
  • f+ f+ is a counter with a variable increment that outputs its current count as a float, making it quick and easy to build a counter with metrum.
  • math.nan~ math.nan~ outputs a NaN signal for use in Pd signal processing.
  • tab_add tab_add adds samples from two source arrays and writes the sums to a destination array; a bang performs the operation.
  • complex.div complex.div divides one complex number by a divisor and outputs the result as Complex data.
  • cconj~ cconj~ computes the complex conjugate of a complex signal.
  • plot.geomspace~ plot.geomspace~ outputs a signal containing a specified number of values evenly spaced on a logarithmic scale, for use with array.plot~ or ui.plot~.
  • ratio2cents The ratio2cents object converts musical intervals expressed as rational numbers (floating-point decimals) into cents.
  • 0x5e 0x5e (shown as ^) performs a bitwise exclusive OR (XOR) operation.
  • curve_pow curve_pow generates a power-based curve for mapping values to an output range of 0 to 1.
  • array.sum2 array.sum2 calculates the sum of the squares of all elements in a named array and outputs the resulting value.
  • min__ min__ compares double-precision numbers and outputs the lesser value, with the help patch claiming 15-digit accuracy.
  • radians2mapping radians2mapping converts a float in the range −π to π from radians into the mapping representation.
  • tavg~ The tavg~ object calculates the arithmetic mean of an incoming audio signal.
  • fd_map2 fd_map2 linearly maps an input float from one range (a–b) to another range (c–d).
  • curves curves converts input values through selectable curve functions, including exponential, bounce, sine, logarithmic, window, and linear mappings.
  • sgn~ The sgn~ object calculates the signum of an incoming audio signal, outputting 1 for positive values, -1 for negative values, and 0 for zero.
  • polar polar converts Cartesian coordinates (x, y) to polar coordinates.
  • math.tanh~ math.tanh~ calculates the hyperbolic tangent of an input signal and outputs the result as a signal.
  • rmstofad rmstofad converts a linear RMS value to a fader-scale value.
  • math.e math.e provides the mathematical constant e, the base of the natural logarithm, approximately 2.71828.
  • vrmstodb vrmstodb converts an RMS value or a list (vector) of RMS values to decibels.
  • fd_sinc fd_sinc computes a sinusoidal pulse.
  • mtx_atan2 mtx_atan2 computes the arctangent (atan2) element-wise for matrix data and outputs a matrix.
  • conv.ms2samp conv.ms2samp converts time in milliseconds to a number of samples.
  • list.normalize list.normalize normalizes a list of floats either by scaling the values so their sum is 1.0 or by mapping their value range to 0–1.
  • divl~ divl~ performs signal division, with the second operand changing through line~-style interpolation.
  • hz2mel The hz2mel object converts a frequency value, given in Hertz (Hz), into its corresponding value on the Mel scale.
  • tab_mul_scalar tab_mul_scalar multiplies samples from a source array by a scalar and writes the results to a destination array.
  • cexp~ cexp~ performs a complex exponential on signal input, providing signal outputs for the complex result.
  • fold The fold object mirrors an input value back into a specified low and high range.
  • math.log math.log computes the natural logarithm of an input value.
  • keepMin keepMin outputs the smallest number received since initialization or the last bang on its cold inlet.
  • weightonset weightonset calculates an onset-weighted moving average of successive float inputs, with later values influenced according to an influence factor and an optional attack phase.
  • round_zero round_zero rounds very small numbers between plus and minus a specified threshold.
  • tdh.math.dbfs2lin tdh.math.dbfs2lin converts a gain value from decibels full scale (dBFS) to a linear gain value.
  • operator~ operator~ applies multiplication and addition to signals, and can also be configured as a sine-wave oscillator.
  • array-freqtobin Upon receiving a bang, array-freqtobin converts every frequency value in the referenced array from Hz to an FFT bin index.
  • rand.i~ The rand.i~ object generates pseudo-random integer values within a specified range, outputting them as an audio signal.
  • vcog vcog computes the center of gravity of a list of floats, representing a virtual position within that list.
  • matrix.logspace matrix.logspace generates a matrix row of N logarithmically spaced values from 10^A through 10^B, including the endpoint.
  • min~~ min~~ performs a double-precision comparison and outputs the lesser value.
  • breakpoint_smooth breakpoint_smooth curves a control input in the 0-to-1 range using a double-linear mapping, producing a curved float output.
  • tab_min_index tab_min_index calculates the minimum element in a source array and outputs both its value and index when it receives a bang.
  • jp.dbtofad jp.dbtofad is a vanilla Pd model of iemlib/dbtofad that converts a MIDI-dB value into a fader-scale value.
  • complex.sin complex.sin computes the sine of a complex number and outputs the result as Complex data.
  • acos~ The acos~ object calculates the arc-cosine of an incoming signal, sample by sample.
  • --value --value provides a pre-decrement operation for a named Pd value, such as $0-apple.
  • math.sinh math.sinh computes the hyperbolic sine of an input value.
  • matrix.mean_row matrix.mean_row computes the mean value of each row in a matrix.
  • framedelta~ The framedelta~ object computes the difference between successive signal blocks, specifically designed for running phase deviation in FFT analysis.
  • pwrap pwrap performs parameterized wrapping of floats into a range, providing an alternative to clipping values at the limits.
  • chair.increment chair.increment maintains a numeric value and changes it in response to numeric messages, as illustrated with -1 and 1.
  • mapping2degrees mapping2degrees converts a float from the mapping range (0 to 1) into degrees.
  • linspace linspace generates a list of linearly spaced floats between a start value and an end value.
  • chair.distance chair.distance is a simple calculator for the distance between two points.
  • lorsig~ lorsig~ computes the Lorenz equations for every audio sample, producing a signal defined as sqrt(lorenzdist^2 + in^2) * 0.1.
  • pol2car~ The pol2car~ object converts polar coordinates (amplitude and phase) into cartesian coordinates (real and imaginary parts).
  • math.trunc~ math.trunc~ truncates an input signal to integer values and outputs the resulting signal.
  • polar2cartesian polar2cartesian converts 2D polar or 3D cylindrical coordinates (r, phi, z) into Cartesian coordinates (x, y, z).
  • lcm The lcm object calculates the least common multiple (LCM) of two or more floating-point numbers.
  • curve_draw curve_draw is a GUI control abstraction for drawing an input-to-output mapping curve, with both input and output ranging from 0 to 1.
  • rational.div rational.div divides a rational number by a divisor and outputs the result as Rational data.
  • math.exp2 math.exp2 computes the base-2 exponential, 2**x, for an input value.
  • maximum~ The maximum~ object outputs a signal representing the greater of two input signals, or the greater of an input signal and a numerical argument.
  • mtx_distance mtx_distance calculates the Euclidean distance matrix between two sets of vectors supplied as matrices, with each row defining a vector of the same dimension.
  • inv inv computes the inverse of a control-rate float.
  • atanh The atanh object calculates the hyperbolic arc-tangent of a given float input.
  • fluid.nmfmorph~ The fluid.nmfmorph~ object performs cross-synthesis between two audio sources using Nonnegative Matrix Factorization (NMF) and Optimal Transport (OT).
  • simplified_cubic_seat simplified_cubic_seat curves a control input using a simple cubic function, mapping the output to the range 0–1.
  • chair.angle chair.angle calculates the angle between two vectors in Cartesian coordinates.
  • cart2pol The cart2pol object converts 3D Cartesian coordinates (x, y, z) into 3D polar coordinates.
  • beat2frac beat2frac converts a beat division into its length as a fraction, for use with a tempo expressed in milliseconds per beat.
  • vpow vpow raises each input float, or each element of an input list, to a specified power, computing y(i) = x(i)^a.
  • math.div math.div divides a float or each valid float in a list by a configurable divisor, providing division for both scalar and list data.
  • math.expr math.expr dynamically evaluates a mathematical expression and outputs the calculated result for incoming floats or lists.
  • car2pol The car2pol object converts Cartesian coordinates (real and imaginary parts) into their polar form (amplitude and phase).
  • log2 log2 calculates the base-2 logarithm of an input value.
  • complex.polar complex.polar creates and outputs a complex number from polar coordinates: a magnitude and a phase angle in radians.
  • math.cmul~ math.cmul~ multiplies two complex signals, with four signal inlets accepting the real and imaginary parts of each input.
  • smap smap remaps an input value from the 0–127 MIDI range to a specified output range.
  • stepper stepper is a control abstraction for mapping values to a stepped output in the 0-to-1 range.
  • mstos mstos determines how many samples correspond to a given duration in milliseconds.
  • tab_add_scalar tab_add_scalar adds a scalar value to samples from a source array and writes the results to a destination array.
  • mstosamps~ The mstosamps~ object converts a time value in milliseconds into the corresponding number of audio samples, taking the current sample rate into account.
  • cinv~ cinv~ computes the complex inverse of a pair of input signals, producing a pair of output signals.
  • complex.== complex.== checks whether two numbers are equal, outputting 1 when they are equal and 0 otherwise.
  • mtx_distance2 mtx_distance2 calculates a matrix of squared Euclidean distances between two sets of vectors, with each input matrix’s rows representing vectors of the same dimension.
  • mtx_abs mtx_abs computes the absolute value of each element in an input matrix and outputs the resulting matrix.
  • fd_distributions fd_distributions plots a selected distribution into a named array and is the predecessor of fd_windows.
  • shadylook~ shadylook~ is the signal-rate version of shadylook.
  • car2pol~ The car2pol~ object converts Cartesian coordinates (real and imaginary parts) of an audio signal into polar coordinates (amplitude and phase).
  • sigmoide The help patch identifies sigmoide as a control abstraction with two float inlets and one float outlet, apparently intended for sigmoid-style mapping.
  • atodb The atodb object converts linear amplitude values to their decibel full scale (dBFS) equivalents.
  • array-dbtorms array-dbtorms converts every value in the currently referenced array from dB to RMS amplitude units when it receives a bang.
  • tab_max tab_max writes the element-wise maximum of two source arrays into a destination array.
  • add~~ add~~ performs double-precision signal addition, providing a 15-digit-accurate sum.
  • fd_norm-abs fd_norm-abs normalizes an input range over time, mapping values from -1…1 to 0…1.
  • bitsplit~ bitsplit~ splits an input signal into a parallel binary word, with each bit provided as a signal outlet.
  • abs~ The abs~ object calculates the absolute value of an incoming audio signal.
  • math.asinh~ math.asinh~ computes the principal value of the hyperbolic arc sine for an input signal and outputs the result as a signal.
  • array-offset array-offset adds an offset received at its first inlet to every value in the currently referenced array.
  • variance variance computes the variance of incoming float values, presumably for control-data analysis.
  • div~~ div~~ performs double-precision signal division and produces a quotient, with the help patch claiming 15-digit accuracy.
  • curve~ curve~ generates non-linear, curved ramp signals, offering an exponential curve factor to shape the transition between values.
  • dec2hex The dec2hex object converts incoming decimal numbers or lists of numbers into their hexadecimal string representations.
  • tblock tblock converts block-relative time values for spectral-domain processing, computing its output as left input + right input × (block size / system sample rate).
  • ls.mean ls.mean calculates the mean of a list of numbers.
  • math.log2~ math.log2~ computes the base-2 logarithm of each value in an input signal and outputs the result as a signal.
  • matrix.cosh matrix.cosh computes the hyperbolic cosine of each element in an input matrix and outputs a new matrix.
  • rm~ rm~ is a Pure Data abstraction that performs ring modulation on an input signal.
  • spiral spiral converts Cartesian x/y coordinates to polar radius and angle values while allowing the angle to continue increasing or decreasing across rotations.
  • int_fract~ int_fract~ efficiently separates a 32-bit floating-point signal into its integer and fractional parts.
  • list-accum list-accum adds all floats in an input list and outputs the result.
  • mtx_sph2cart mtx_sph2cart converts spherical coordinates to Cartesian coordinates in matrix form.
  • sampstoms~ The sampstoms~ object converts a time value from samples to milliseconds, taking the current sample rate into account.
  • add__ add__ performs double-precision addition, with the equivalent names +__ and +''.
  • mtx_cholesky mtx_cholesky decomposes an input matrix using Cholesky's algorithm and outputs the result as a matrix.
  • map~ easyflow/map~ converts a signal from one range to another, such as mapping an osc~ signal from -1–1 to 0–255.
  • math.squared~ math.squared~ squares each value of an input signal and outputs the resulting signal.
  • combi combi finds all possible combinations of r elements from an incoming list of size n.
  • hopalong hopalong generates X and Y values for a Hopalong attractor, which the help patch notes is not continuous.
  • fd_bark fd_bark calculates the Bark scale over a specified minimum-to-maximum range and writes the result to a named array.
  • ED2EP ED2EP converts a series of entry delays (ED) into entry points (EP), providing cumulative timing positions for a rhythm.
  • lhisti lhisti creates a leaky histogram from float or list input, assigning samples to a configurable number of classes without clipping out-of-range values.
  • mtx_diff mtx_diff calculates forward or backward differences between matrix elements, making it useful for numerical derivatives of vectors and matrices.
  • cosinterp~ cosinterp~ performs cosine interpolation.
  • absgn~ The absgn~ object calculates the absolute value and the signum of an incoming audio signal.
  • list-inter-many list-inter-many performs elementwise linear interpolation between several float lists, outputting the interpolated list.
  • fd_lorenz fd_lorenz is a simplified Lorenz-system abstraction that iteratively computes the system’s x, y, and z state from configurable rho, beta, sigma, step size, and initial conditions.
  • listMax listMax outputs the maximum numeric value in a list.
  • numeric numeric is an overview patch for ceammc objects that create, inspect, convert, compare, and perform arithmetic on complex and rational numbers.
  • transpose transpose takes an interval in semitones as input and outputs an approximate transposition.
  • array-differentiate array-differentiate replaces the values in its currently referenced array with differences between neighboring values, such that each new value_i equals value_i minus value_i-1.
  • nl nl is a control abstraction that produces an XY relation for a non-linearity operation, taking float input through two inlets and outputting a float.
  • math.log~ math.log~ computes the natural logarithm of each value in an input signal and outputs the result as a signal.
  • math.gamma math.gamma computes the gamma function, extending the factorial function to real numbers; for any positive integer n, Γ(n) = (n−1)!.
  • matrix.asinh matrix.asinh computes the element-wise inverse hyperbolic sine of a matrix, producing a new matrix.
  • array-floor Upon receiving a bang, array-floor rounds every value in the currently referenced array down to the next lower integer.
  • round~ The round~ object quantizes incoming audio signals to an integer multiple of a specified value.
  • valueOp valueOp reads two named value objects and performs a specified operation on their stored values.
  • array.minmax array.minmax searches a named Pd array for its minimum and maximum element values, outputting those values as a two-element list and their indexes from a second outlet.
  • avg~ The avg~ object calculates the absolute average of an input signal.
  • phon2sone The phon2sone object converts a loudness level expressed in phons to a perceived loudness value in sones.
  • curve_graph curve_graph is a GUI control abstraction for drawing an arbitrary curve and using it for curve mapping.
  • ucnorm~ ucnorm~ normalizes a complex signal to unit magnitude.
  • hid_centered hid_centered converts the standard 0-to-1 output format of hid to a centered range beginning at -1.
  • sinx~ The sinx~ object calculates the sine of an incoming signal.
  • quartic quartic curves a control input using a quartic function, mapping the output to the range 0 to 1.
  • math.abs~ math.abs~ computes the absolute value of an input signal and outputs the resulting signal.
  • conv.phase2rad conv.phase2rad converts phase values in the range 0–1 to radians in the range 0–2π.
  • mtx_logsweep mtx_logsweep creates a matrix vector containing an n-sample logarithmic sweep between specified starting and stopping digital frequencies.
  • bytemask bytemask generates a bitmask byte from values received through its eight float inlets and outputs the result as a float.
  • trunc The trunc object truncates floating-point numbers and lists of numbers towards zero, effectively extracting only the integer part of each number.
  • sum~ The sum~ object takes a multichannel audio signal and sums all channels into a single mono output.
  • expmap~ expmap~ exponentially maps an input signal from the range (-1, 1) to a specified minimum and maximum, producing a signal output.
  • stoms stoms converts a number of samples into the equivalent duration in milliseconds.
  • matrix.identity matrix.identity creates and outputs an identity matrix for use in matrix operations.
  • conv.ms2samp~ conv.ms2samp~ converts an input signal representing time in milliseconds into an output signal representing the corresponding number of samples.
  • fd_emap2 fd_emap2 maps a float linearly from an incoming range to a new range, with the four creation arguments specifying the two ranges.
  • mull~ mull~ multiplies a signal by a multiplication factor that is interpolated using a line~-style ramp.
  • ratio2cents~ The ratio2cents~ object converts a signal representing a rational interval into an interval expressed in cents.
  • minimum~ The minimum~ object outputs the smaller of two input signals, or the smaller of an input signal and a numerical argument.
  • mtx_log mtx_log computes the natural logarithm of each element in an input matrix and outputs the resulting matrix.
  • vrms vrms computes the root-mean-square of a vector from a list of input values and outputs a float.
  • mass2D The mass2D object simulates a 2D mass, calculating its position and velocity based on applied forces, weight, and damping.
  • math.tan~ math.tan~ computes the tangent of each input signal value, measured in radians, and outputs the result as a signal.
  • poltocar~ The poltocar~ object converts signal values from polar coordinates (amplitude and phase) to Cartesian coordinates (real and imaginary parts).
  • rewrap rewrap wraps input floats back and forth within a range, using lower and upper limits.
  • list.runsum list.runsum computes the running (cumulative) sum of an input list, producing a result list whose elements are the successive partial sums.
  • rational.reciprocal rational.reciprocal outputs the reciprocal of a rational number.
  • math.tanh math.tanh computes the hyperbolic tangent of an input value.
  • nearest nearest rounds an input float to the nearest integer, providing an easy-to-remember alternative to an equivalent expression.
  • elliptic elliptic curves an input range using two ellipses, mapping the output to the range 0–1.
  • taint~ The taint~ object performs spectral multiplication, combining the frequency spectra of two input audio signals.
  • math.squared math.squared calculates the square of an input value.
  • log~ nilwind/log~ outputs the logarithm of an input signal using a specified base and is useful for generating curves from line~.
  • complex.sqrt complex.sqrt computes the complex square root in the right half-plane.
  • asinh~ The asinh~ object computes the hyperbolic arc-sine of an incoming audio signal, sample by sample.
  • tanh The tanh object calculates the hyperbolic tangent function of a given number.
  • mtx_sqrt mtx_sqrt calculates the square root of each element in an input matrix and outputs the resulting matrix.
  • scale The scale object maps an input numerical range to an output numerical range, allowing for inversion and exponential scaling.
  • asin The asin object calculates the arc-sine of a given float input.
  • 1-0switch~ 1-0switch~ is a wrapper that computes 1 minus its argument.
  • cxstddev cxstddev calculates the standard deviation of the values in a named Pd array and outputs it as a float.
  • pdp_abs pdp_abs computes the absolute value of its input, which is useful for converting negative values to their positive magnitudes.
  • lincong~ The lincong~ object is a chaotic signal generator based on the linear congruential algorithm, similar to SuperCollider's LincongN UGEN.
  • ccmap~ ccmap~ implements the conformal self-map of the unit disk given by (z-a)/(1-conj(a)z).
  • list-normalize list-normalize scales a list so that the element with the largest absolute value becomes 1 in magnitude, with all other float elements scaled by the same factor.
  • fd_welch~ fd_welch~ generates the same Welch window as fd_welch, but writes it into an array using DSP; it is used by fd_windows.
  • gingerbreadman gingerbreadman generates the X and Y values of the discontinuous Gingerbreadman attractor, a parameterless fractal equation.
  • v-- v-- is a shorthand for the value-- object.
  • list-harmonic-mean list-harmonic-mean calculates the harmonic mean of the floats in an input list and outputs a float.
  • sinusoid sinusoid maps an input range to a sinusoidal curve, producing output in the range 0 to 1.
  • mtx_bessel mtx_bessel calculates Bessel functions for the elements of an input matrix and outputs matrix results.
  • trans-exp trans-exp outputs the nth member of an exponential transition row, selected by an integer in its left inlet.
  • cubic_seat cubic_seat curves a control input using cubic curves, mapping the result to an output range of 0 to 1.
  • pol2sph The pol2sph object converts 2D polar coordinates (radius, angle, and height) into 3D spherical coordinates.
  • distance_n distance_n calculates the distance between a point and a stream of points in n-dimensional space, outputting the result as a float.
  • quantizer The quantizer object approximates input float values or lists of floats to discrete step values.
  • conv.bpm2hz conv.bpm2hz converts a float frequency expressed in beats per minute (BPM) to frequency in hertz.
  • lor~ lor~ computes the Lorenz equations, with separate signal inlets for the step and the system coefficients a, b, and c.
  • list-add list-add subtracts two lists element by element and outputs the resulting list.
  • mtx_sin mtx_sin calculates the sine of each element in an input matrix and outputs the resulting matrix.
  • note2st note2st outputs the intervals of an incoming stream of notes.
  • cents2frac The cents2frac object converts musical intervals expressed in cents into fractional values, representing ratios.
  • fd_log fd_log applies a normalized logarithmic function to input floats in the 0–1 range and outputs the resulting float.
  • fmod fmod is the floating-point version of mod, intended for modulo operations on float values.
  • tab_derivate tab_derivate computes the derivative of a source array and writes the result to a destination array.
  • ls.ser.arithm ls.ser.arithm generates an arithmetic series from a low value to a high value in a specified number of steps.
  • mstof mstof converts milliseconds to frequency or vice versa.
  • pdp_mix2 pdp_mix2 adds two packets after applying attenuation to each input.
  • conv.bits2int conv.bits2int converts an input list of bits to an integer, providing the inverse-style conversion associated with conv.int2bits.
  • math.carg~ math.carg~ calculates the phase angle of a complex signal from its real and imaginary input signals.
  • hz2bark The hz2bark object converts a given frequency in Hertz (Hz) to its equivalent value on the Bark scale, a psychoacoustical scale for perceived pitch.
  • tanx~ tanx~ calculates the tangent of an incoming signal, expecting its input in radians.
  • v++ v++ is a shorthand for value++.
  • flenc flenc joins separate sign, exponent, and mantissa components to encode a floating-point value, complementing fldec, which splits a float into those components.
  • math.sync_mod math.sync_mod synchronously calculates the remainder of float or integer modulo division, with the remainder signed like the dividend.
  • list-mode list-mode returns the statistical mode—the most frequent item or items—of a list of integers.
  • tab_div tab_div divides the samples of two source arrays and writes the results to a destination array.
  • tab_min tab_min computes the sample-by-sample minimum of two source arrays and writes the results to a destination array.
  • mag~ The mag~ object calculates the magnitude (amplitude) of a signal from its real and imaginary components, functioning similarly to the amplitude output of car2pol~.
  • divide divide is like Pd’s / object but outputs a floating-point result when either the leftmost or second inlet changes.
  • openmusic openmusic is loaded as a library with declare -lib openmusic and provides arithmetic objects such as py+, py-, py*, and py/ for use with py4pd.
  • conv.bar2ms conv.bar2ms calculates bar and beat durations from a tempo and time signature, outputting their periods in milliseconds from its first and second outlets.
  • mtx_exp mtx_exp computes the exponential of each element in an input matrix and outputs the resulting matrix.
  • inverter inverter is a voltage-inverter module that accepts a signal at IN and provides the inverted signal at OUT.
  • math.sync_add math.sync_add performs synchronous addition, calculating and outputting the result whenever either addend changes.
  • csub~ csub~ performs complex subtraction on signal inputs.
  • average~ average~ calculates a moving average of an audio signal over a specified number of recent samples.
  • clifford clifford computes the Clifford attractor described by Paul Bourke.
  • ffpoly ffpoly computes a finite-field polynomial, with creation arguments specifying the polynomial order and finite-field order.
  • ease ease applies a selected easing function to input values from 0 to 1, with some functions producing outputs from approximately -0.3 to 1.3.
  • tab_carth2polar tab_carth2polar converts Cartesian complex data from real and imaginary source arrays into magnitude and phase-argument destination arrays.
  • fad2rms fad2rms converts fader-scale values to linear RMS values.
  • array-scale array-scale multiplies every value in the currently referenced array by an incoming scalar value.
  • envelope~ The envelope~ object generates various envelope waveforms based on a phase input.
  • db2lin~ The db2lin~ object converts decibel full scale (dBFS) amplitude values to linear amplitude values using the formula amp = 10^(dBFS / 20).
  • math.round~ math.round~ rounds each value of an input signal and outputs the resulting rounded signal.
  • valueOpSet valueOpSet reads two value objects, performs the specified operation on their values, and outputs the result.
  • math.sync_div math.sync_div performs synchronized division, recalculating and outputting the result whenever either the dividend or divisor is set; a two-item list sets both values and calculates immediately.
  • matrix.sin matrix.sin computes the sine of each element in a matrix and outputs a new matrix.
  • minmax The minmax object takes a list of floating-point numbers as input.
  • add The add object accumulates incoming float values, outputting the current sum.
  • complex.real complex.real extracts the real part of a complex number and outputs it as a float.
  • list.inc list.inc generates a numerical list based on a starting value, a step value, and the desired number of elements.
  • mtx_tan mtx_tan computes the tangent of each element in an input matrix and outputs the resulting matrix.
  • list-invint list-invint calculates the inverse musical intervals of a list of floats.
  • quad~ The quad~ object generates a chaotic audio signal using a general quadratic map.
  • henon~ The henon~ object generates a chaotic audio signal based on the Hénon map difference equation.
  • scale2cents The scale2cents object converts a musical scale defined by steps in semitones into corresponding cent values.
  • mtx_dbtopow mtx_dbtopow converts each element of an input matrix from Pd-style dB values to power values.
  • pong~ The pong~ object functions as a signal range limiter, enabling users to fold, wrap, or clip an input signal within a defined low-high range.
  • dbtomag~ dbtomag~ converts dB-FS decibel signal values to magnitude values.
  • math.binomial math.binomial calculates binomial coefficients for use with Pascal’s triangle.
  • math.ceil~ math.ceil~ rounds each input signal value to the smallest integral value that is not less than it, providing a signal-rate ceiling operation.
  • fd_n! fd_n! computes the factorial of a number, either from a float input or from its creation argument when triggered by a bang.
  • mtx_add mtx_add performs matrix addition, either adding two matrices or adding a scalar offset to a matrix.
  • dbtoa~ The dbtoa~ object converts a decibel full scale (dBFS) amplitude signal or float into its linear amplitude equivalent.
  • acosh The acosh object calculates the hyperbolic arc-cosine of a given floating-point number.
  • median_7 median_7 is a control abstraction that outputs the median value of the last seven float samples.
  • qmult~ qmult~ multiplies two quaternion signals, providing a form of “quaternion ring modulation.” It accepts each quaternion through four signal inlets arranged as one real component followed by three imaginary components, and outputs the resulting quaternion as four signals..
  • mtx_dbtorms mtx_dbtorms converts each element of an input matrix from Pd-style dB values to linear RMS values.
  • lin2db~ The lin2db~ object converts linear amplitude values to decibels full scale (dBFS) using the formula dbFS = log10(amp) * 20.
  • matrix.inverse matrix.inverse computes the inverse of a square matrix and outputs the result as a new Matrix.
  • multatord~ multatord~ multiplies an input signal by a factor and then adds an offset, making it useful for signal scaling and shifting.
  • cartesian2spherical cartesian2spherical is a control abstraction that the help patch describes as converting spherical coordinates (r, phi, theta) to Cartesian coordinates (x, y, z), despite its contradictory name.
  • sinh~ The sinh~ object calculates the hyperbolic sine of an incoming signal, sample by sample.
  • db2fad db2fad converts a dB value to a fader-scale value.
  • hotbinops1 hotbinops1 provides arithmetic objects with hot inlets, including #+, #-, #*, #/, #pow, #max, and #min.
  • trans trans generates a transition row from a start value to an end value over a specified number of steps, using logarithmic, linear, or exponential interpolation.
  • ^ ^ performs bitwise exclusive OR (XOR), using the same operator symbol as C.
  • tempo The tempo object functions as a metronome, sending bangs at a specified rate in BPM, Hz, or milliseconds.
  • add~ The add~ object continuously accumulates incoming signal or float values, adding them to a running sum.
  • hid_rel2abs hid_rel2abs converts relative axis data into an absolute position and outputs it as a float.
  • median~ The median~ object calculates the median value of an incoming audio signal over a user-specified number of samples.
  • math.gcd math.gcd calculates the greatest common divisor of two integers.
  • modulo~ The modulo~ (or %%~) object is a signal remainder operator.
  • rescale~ The rescale~ object transforms input signal values from one range to another, with configurable minimum and maximum input/output values.
  • mtx_gauss mtx_gauss applies Gaussian elimination, using row and column transformations to shape an input matrix into an upper-triangular matrix.
  • array-geomean array-geomean outputs the geometric mean of the currently referenced array when it receives a bang.
  • amptodb~ amptodb~ converts amplitude values at its inlet to dB-FS decibel values at its outlet.
  • ceil~ The ceil~ object performs a ceiling mathematical operation on incoming audio signals.
  • mtx_linspace mtx_linspace creates a linearly spaced matrix vector from a start value to a stop value with a specified number of entries.
  • matrix.range matrix.range computes the range of matrix data, defined as the difference between its maximum and minimum values.
  • iCircle2D The iCircle2D object simulates circular interactions in 2D space, applying various forces and displacements to an interacting mass.
  • list-emath list-emath performs a selected arithmetic operation on two lists element by element, with operators such as +, -, *, and / specified as its argument.
  • mtx_.cabs2 mtx_.cabs2 computes the element-wise absolute value of a complex-valued matrix and outputs a real-valued matrix.
  • pow~ The cyclone/pow~ object calculates the power of a base value, raising it to the exponent.
  • mapping2radians mapping2radians converts numbers from the mapping range into radians.
  • array-ceil Upon receiving a bang, array-ceil rounds every value in the currently referenced array up to the next highest integer.
  • ratio ratio is a control-rate octave shifter that maps a float input to an output between 1 and 2.
  • mix4~ The mix4~ object is a convenient 4-channel audio mixer abstraction for Pure Data, offering independent gain and panning controls for each input.
  • conv.sec2samp conv.sec2samp converts a time in seconds to a number of samples.
  • fad2db fad2db converts a fader-scale value to a decibel (dB) value.
  • cents2ratio The cents2ratio object converts musical intervals expressed in cents into their corresponding frequency ratios, output as floating-point decimals.
  • fd_tempo-msec fd_tempo-msec converts an input tempo in beats per minute (BPM) to the corresponding duration in milliseconds.
  • mtx_cumprod mtx_cumprod computes the cumulative product of a matrix in either the row or column direction, which can be used to calculate factorials or geometric series.
  • conv.ms2bpm conv.ms2bpm converts a period given in milliseconds to its corresponding frequency in beats per minute (BPM).
  • cmplxsub~ cmplxsub~ subtracts one complex number from another, outputting the real and imaginary parts of the difference through separate outlets.
  • deg2hid deg2hid converts degree values to the numeric range used by hid.
  • list.max list.max outputs the largest element in an input list or mlist.
  • math.cos math.cos computes the cosine of an input value and outputs the result.
  • conv.lin2lin~ conv.lin2lin~ converts an input signal from one linear range to another, with four float arguments specifying the input and output range endpoints.
  • atan2~ The atan2~ object calculates the arc-tangent of two signal-rate input values, 'a' and 'b', as atan(a/b).
  • count The count object acts as a versatile counter, incrementing or decrementing a numerical value within specified minimum and maximum bounds.
  • min_n min_n returns the minimum among the last n input values, providing a rolling minimum over recent data.
  • mag The mag object calculates the magnitude (amplitude) of a complex number, taking its real and imaginary parts as input.
  • symtodp symtodp converts a symbol representing a number into the two-float representation used for a double-precision value.
  • ceammc.math ceammc.math is the ceammc library’s collection of mathematical objects, covering arithmetic, functions, constants, comparisons, complex-signal operations, and related utilities.
  • tab_integrate tab_integrate integrates values from a source array into a destination array.
  • tab_sub tab_sub subtracts samples from two source arrays and writes the results to a destination array.
  • math.neg math.neg negates an input value, returning the value with the opposite sign.
  • tSphere3D The tSphere3D object performs a spherical test to determine if a "mass" (likely a point or object) is located within a defined 3D spherical region.
  • dbpole dbpole converts a time in milliseconds into a pole value for a decay from 1 to 0.001 (60 dB).
  • streamMinMax tof/streamMinMax tracks a number stream and outputs its minimum and maximum float values through two outlets.
  • tab_mul tab_mul multiplies corresponding samples from two source arrays and writes the results to a destination array; a bang performs the operation.
  • multi multi multiplies the values of all its inlets and outputs the result when its leftmost or second inlet receives a value; a bang calculates and outputs the current result.
  • plusequals~ The plusequals~ (or +=~) object is a signal accumulator that continuously sums its input samples, generating a running total.
  • math.cabs~ math.cabs~ calculates the magnitude of a complex signal.
  • math.cbrt~ math.cbrt~ computes the cube root of each value in an input signal and outputs the resulting signal.
  • commonality The commonality object calculates the 'Pitch Commonality' between three or more specified pitches.
  • tab_sum tab_sum calculates the sum of elements in a named source array and outputs the result as a float.
  • rint~ The rint~ object rounds an incoming signal to the nearest integer value.
  • indigestibility The indigestibility object calculates Clarence Barlow's 'indigestibility' measure for an integer.
  • conv.samp2sec conv.samp2sec converts a number of samples to time in seconds according to the sample rate.
  • hid_exp hid_exp maps a float input range to an exponential curve, intended for control-value conversion such as reshaping the normalized 0-to-1 output of hid.
  • bicoeff2 The bicoeff2 object generates coefficients for Pure Data's vanilla biquad~ object, which implements various audio filters.
  • ceammc.conv ceammc.conv is an index of conversion objects in the ceammc library, covering numeric ranges, time and samples, musical values, coordinates, colors, and data representations.
  • list-geometric-mean list-geometric-mean calculates the geometric mean of the floats in an input list and outputs the result as a float.
  • vector+ vector+ adds a constant offset to a vector, where a vector is a list of numbers.
  • sone2phon The sone2phon object converts a loudness value expressed in sones to phons.
  • complex.mul complex.mul multiplies complex numbers and outputs the result as Complex data.
  • floor~ The floor~ object applies the floor mathematical function to incoming audio signals, rounding each sample down to the nearest integer.
  • subl~ subl~ performs signal subtraction using a second operand that is interpolated like line~.
  • track_min track_min tracks the minimum value received.
  • matrix_mul_line8~ matrix_mul_line8~ multiplies a signal-input vector by a dynamically changeable matrix to produce a signal-output vector (SIG_OUT = A * SIG_IN).
  • rdiv~ The rdiv~ object performs signal division, similar to /~, but with its inlets reversed.
  • math.reciprocal math.reciprocal calculates the reciprocal (1/x) of an input float, or outputs a list of reciprocal values for a list input.
  • mirrorwall mirrorwall keeps incoming numbers within a range by folding them backward at its boundaries.
  • op The op object in Pure Data provides a wide range of mathematical, comparative, bitwise, and logical operations.
  • mul~~ mul~~ performs double-precision signal multiplication, producing the product of two double-precision inputs with 15-digit accuracy.
  • tab_powtodb tab_powtodb calculates power-to-decibel values from a source array and writes them to a destination array when it receives a bang.
  • math.floor~ math.floor~ rounds each input signal value down to the largest integer not greater than that value.
  • complex.exp complex.exp computes the base-e exponential of a complex value and outputs the result as Complex data.
  • circular_sigmoid circular_sigmoid curves a control input using a double-circular mapping, producing an output in the range 0 to 1.
  • ls.binop ls.binop performs a binary operation element by element on two lists and outputs the results as a list.
  • math.round math.round returns the nearest integral value for a float and applies the operation to every numeric value in a list.
  • array-std array-std calculates the standard deviation of the currently referenced array when it receives a bang.
  • vlmax vlmax computes a vector leaky maximum from a list of floating-point input values, outputting the maximum value in the list.
  • rminus~ The rminus~ (or !-~) object performs signal subtraction, similar to ~, but with its inlets reversed.
  • tanh~ tanh~ calculates the hyperbolic tangent of an input signal.
  • power~ The power~ object is a signal waveshaper that raises an input signal to a specified exponential factor.
  • frq2note frq2note converts a frequency into a note represented as a MIDI key number.
  • math.atanh~ math.atanh~ computes the principal value of the hyperbolic arc tangent for an input signal.
  • acosh~ The acosh~ object calculates the hyperbolic arc-cosine of an incoming signal, sample by sample.
  • conv.bpm2ms conv.bpm2ms converts a frequency or tempo in beats per minute (BPM) to its period in milliseconds.
  • avg The avg object calculates the mean average of all incoming numbers.
  • poltocar The poltocar object converts polar coordinates (amplitude and phase in radians) into cartesian coordinates (real and imaginary parts).
  • greaterthan~ The greaterthan~ (or >~) object performs a sample-by-sample comparison between two signal inputs.
  • tab_upsample_copy tab_upsample_copy copies data from a source table to a destination table while upsampling it by a specified factor.
  • math.tan math.tan computes the tangent of an input value.
  • correlation correlation measures the correlation between two float streams, with one stream supplied to each inlet.
  • distance2d distance2d calculates the 2D distance between a point and a stream of points, outputting the result as a float.
  • one2three one2three is a control abstraction for simple one-to-three mapping, taking float input and providing three float outputs.
  • list-dotprod list-dotprod computes the dot product of two input lists as the sum of corresponding element-wise products (res = sum(Xi*Yi)); for example, lists 2 4 and 3 1 produce 10.
  • scaler~ scaler~ scales a signal by multiplying it and then adding an offset.
  • swe~ swe~ uses Swiss Ephemeris data to calculate astronomical-body longitude, latitude, and distance, including at audio rate or into a Pd array.
  • conv.amp2dbfs~ conv.amp2dbfs~ converts an input amplitude signal to a decibel full-scale (dBFS) signal using 20 × log10(amplitude).
  • hid_square hid_square maps a float input in the hid output range of 0 to 1 onto a square curve.
  • bpmtoms bpmtoms is a convenience object equivalent to expr 60000 / $f1.
  • math.cdiv~ math.cdiv~ divides one complex signal by another, with four signal inlets for the real and imaginary parts of the two inputs and outputs for the result’s real and imaginary parts.
  • fd_norm fd_norm normalizes a stream of floats against a range learned over time, providing normalized outputs for 0–1 and −1–1 ranges.
  • ms2samps~ The ms2samps~ object converts time values from milliseconds to the corresponding number of audio samples.
  • mtx_roty mtx_roty produces a three-dimensional Cartesian rotation matrix for rotation around the y-axis.
  • bin2num bin2num takes a list of 0s and 1s and outputs the corresponding number.
  • math.polyeval math.polyeval evaluates a polynomial defined by a coefficient list, such as coefficients 2 4 5 6 representing y = 2x³ + 4x² + 5x + 6.
  • array-round array-round rounds every value in the currently referenced array to the nearest integer when it receives a bang.
  • pdp_zthresh pdp_zthresh applies a zero threshold, setting values below 0 to 0.
  • rational.pow rational.pow raises a rational value to an integer exponent and outputs the result as Rational data.
  • numeric.rational numeric.rational is a library module providing rational.new and related objects for creating, converting, comparing, and performing arithmetic on rational numbers.
  • math.cexp~ math.cexp~ computes the base-e exponential of a complex signal.
  • vector0x2a vector0x2a multiplies a vector—a list of numbers—by a numeric factor and outputs the resulting list.
  • tinkerbell tinkerbell represents the non-continuous Tinkerbell attractor and is intended for finding a random attractor set.
  • vnmax vnmax finds the maximum value in a list of floats.
  • math.sqrt~ math.sqrt~ computes the square root of an input signal and outputs the result as a signal.
  • fd_reflect fd_reflect reflects a float input between symmetric lower and upper boundaries.
  • mtx_.cmul mtx_.cmul performs element-wise multiplication of two complex-valued matrices.
  • vector vector converts Cartesian coordinates (x, y) to polar coordinates.
  • mtx_colon mtx_colon is a matrix colon operator that creates ascending row-vector sequences from start, stop, and increment values, similar to Octave.
  • listMin listMin outputs the minimum numeric value in a list, making it useful for finding a list’s smallest number.
  • mtx_eye mtx_eye creates an identity matrix for control-rate matrix processing.
  • list-inter list-inter performs elementwise linear interpolation between two lists, using a float from 0 to 1 as the distance (factor) between them.
  • list-math list-math performs simple element-wise mathematical operations on lists using a binary operator supplied as its first argument, such as +, -, *, or /.
  • latoocarfian~ latoocarfian~ is a chaotic signal generator that implements the Latoocarfian difference equations.
  • fd_minimax fd_minimax processes a stream of floats and provides the current value together with the minimum and maximum values, serving as an abstraction around minimax.
  • math.nan math.nan outputs a Not-a-Number (NaN) value when it receives a bang.
  • mean~ mean~ is intended to calculate the signal mean of an array, with the array name supplied as its argument.
  • average average averages a series of numbers and outputs the resulting float.
  • freq2midi The freq2midi object converts frequency values (in Hz) to MIDI note numbers, similar to the ftom object.
  • elliptic_sigmoid elliptic_sigmoid curves a control input using a double-linear mapping, producing output in the range 0 to 1.
  • math.sin~ math.sin~ computes the sine of an input signal, with input values interpreted in radians.
  • cgmul~ cgmul~ performs complex multiplication on signal inputs using Gauss’s method.
  • digitCount digitCount outputs the number of digits in a number.
  • hid_polar hid_polar converts Cartesian x/y coordinates to polar coordinates, outputting a radius and an angle.
  • fd_welch fd_welch applies the Welch curve formula, 1-((n-((N-1)/2))/((N-1)/2))², to an input stream and outputs the resulting Welch values.
  • tLine2D The tLine2D object defines a 2D line segment using two points and tracks the position of a "mass" relative to it.
  • plus plus adds the values supplied to its inlets and outputs the result as a float.
  • ++v ++v is a shorthand for the ++value object.
  • dbtoa The dbtoa object converts decibel (dBFS) values into their corresponding linear amplitude using the formula amp = pow(10, dBFS / 20).
  • distance-spearman distance-spearman calculates Spearman's rank correlation between two lists, with the left-inlet list compared against the list supplied to the right inlet.
  • math.sign math.sign computes the sign of an input number, returning -1 for negative values, 0 for zero, and 1 for positive values.
  • lessthan~ The lessthan~ (or <~) object performs a "less than" comparison for audio signals.
  • hid_squareroot hid_squareroot maps float input values in the 0–1 hid output range onto a square-root curve and outputs a float.
  • pattern The pattern object is a rhythmic sequencer that defines musical patterns using note durations, which can be specified as floats or fractions (where 1 is a whole note) with negative values indicating rests.
  • list.product list.product calculates the product of the floats in an input list or mlist and outputs the result as a float.
  • fluid.bufscale The fluid.bufscale object scales numerical values within a buffer from a specified input range to an output range.
  • array-abs-val Upon receiving a bang, array-abs-val replaces every value in the currently referenced array with its absolute value.
  • simplecounter simplecounter is a counter object whose default starting count is 0.
  • math.lcm math.lcm calculates the least common multiple of two integers and outputs the resulting integer.
  • vlavg vlavg computes a leaky average for vectors, outputting a list of averages based on the current and previous input values.
  • tent The help patch identifies tent as a one-variable object and links to examples/readme-fractals, suggesting it is intended for use with fractals.
  • distance The distance object calculates the perceptual distance between pitches.
  • matrix.min matrix.min returns the minimum value in a matrix, outputting the minimum element as a float.
  • lmin lmin is a control-rate filter that computes a leaky minimum from incoming float values and outputs the resulting float.
  • math.gamma~ math.gamma~ computes the gamma function for a floating-point input signal, extending the factorial function to real numbers.
  • rminus The rminus (or !-) object performs subtraction with its inlets reversed compared to the standard [-] object.
  • fd_lorenz-expr fd_lorenz-expr computes the Lorenz equations using expr and outputs the resulting x, y, and z values as a three-float list.
  • lorenz~ The lorenz~ object generates a chaotic audio signal based on the Lorenz strange attractor, a 3D mathematical model.
  • pickover pickover calculates a Pickover attractor, producing X, Y, and Z output values when triggered, for use in chaotic or fractal systems.
  • listOperator listOperator applies a binary operator to each element of a list.
  • mtx_cabs2 mtx_cabs2 computes the absolute value of a complex-valued matrix and outputs a real-valued matrix.
  • math.log10~ math.log10~ computes the base-10 logarithm of an input signal and outputs the result as a signal.
  • 1-0switch 1-0switch is a wrapper for the operation “1 - argument.” Send it a number to subtract that value from 1..
  • standardmap standardmap generates values for the non-continuous Standard Map attractor.
  • fd_arcsin~ fd_arcsin~ is the DSP-based counterpart of fd_arcsin, storing its result in an array, and is used by fd_windows.
  • zigbinops The zigbinops help patch describes a collection of signal-rate Pure Data objects from the zexy library.
  • rad2hz The rad2hz object converts a frequency value from "radians per sample" to Hertz (Hz).
  • tab_cross_corr tab_cross_corr correlates a second source array (the measured signal) with a first source array and writes the result to a destination array when it receives a bang.
  • fd_sinh~ fd_sinh~ is the same as fd_sinh, but stores its result into an array via DSP, and is used in fd_windows.
  • peak The peak object tracks and outputs the highest float value it has received.
  • wrap The wrap object functions as a float-capable modulo, constraining an input float value within specified limits.
  • cents2ratio~ The cents2ratio~ object converts an audio signal representing an interval in cents into a decimal ratio.
  • vfmod vfmod computes the modulo of each float in an input vector (list), outputting a list whose elements are the corresponding input values modulo the current base.
  • simile simile compares two numbers according to an error window, making it useful for comparing values such as pitches or durations.
  • mtx_sum mtx_sum computes the column-wise sum of an input matrix and outputs the sums as a list.
  • mtx_svd mtx_svd computes the singular value decomposition of an input matrix using GSL, expressing it as A = U * S * V^T.
  • simile~ simile~ compares two input signals according to an error measure.
  • trans-log trans-log provides indexed access to a logarithmic sequence, with its arguments indicating the start, end, and number of steps.
  • array-mode Upon receiving a bang, array-mode outputs the mode of the currently referenced array from its first outlet and a list containing the number of occurrences of each value from its second outlet.
  • breakpoint breakpoint curves a 0-to-1 input range into a 0-to-1 output range using a double-linear mapping.
  • array.binop array.binop applies a two-input operation element by element to two input arrays and stores the results in a third array, while also outputting the iterated result values.
  • phasewrap~ The phasewrap~ object wraps an input signal's value between -π and π.
  • vector0x2f vector/ divides a vector—a list of numbers—by a numeric factor and outputs the resulting list.
  • cosx~ The cosx~ object computes the cosine of an input signal, expecting values in radians.
  • array.variance array.variance calculates the variance of the values in a named Pd array.
  • math.acos math.acos computes the principal value of the arc cosine for an input value.
  • lrange lrange outputs the difference between a leaky maximum and a leaky minimum for incoming float values.
  • strange1 strange1 is a non-continuous strange-attractor external intended to find a random attractor set.
  • rms2fad rms2fad converts a linear RMS value to a fader-scale value.
  • list.min list.min returns the smallest element in an input list or mlist.
  • complex.cos complex.cos computes the cosine of a complex number.
  • matrix_diag_mul_line~ matrix_diag_mul_line~ multiplies an n-dimensional signal vector by a dynamically changeable n×n diagonal matrix, producing an n-dimensional signal output vector.
  • hid2deg hid2deg converts floating-point numbers from the normalized hid range into degrees.
  • complex.add complex.add adds two complex numbers and outputs the result as Complex data.
  • nettles nettles is a library of objects that apply binary operations to control messages and signals, including comparisons, reverse subtraction and division, remainder, and signal accumulation.
  • cart2sph The cart2sph object converts 3D Cartesian coordinates (x, y, z) into spherical coordinates (radius, azimuth, elevation).
  • magnetize jl/magnetize maps float values according to a cyclic, repeating pattern of positive-integer intervals.
  • conv.sec2bpm conv.sec2bpm converts a period in seconds to its corresponding frequency in beats per minute (BPM).
  • linedrive The linedrive object scales numbers from one range to another using an exponential curve, similar to cyclone/scale.
  • hid_log hid_log maps a float input in the 0–1 range to a logarithmic curve, producing a float output.
  • fadtorms fadtorms converts a fader-scale value to an RMS value.
  • wrap~~ wrap~~ computes the remainder modulo 1, wrapping an input signal to its fractional part.
  • conv.rad2phase conv.rad2phase converts a value in radians to phase.
  • circular_seat circular_seat curves an input range using a double-circular mapping, producing a float output in the range 0 to 1.
  • array-mink array-mink returns the k smallest values in the currently referenced array as a list from its first outlet.
  • list-unitvec list-unitvec converts an input list into a unit vector.
  • tabgen The tabgen object is a Pure Data abstraction for generating and populating named tables (arrays) with various mathematical functions.
  • matrix.exp10 matrix.exp10 computes the element-wise base-10 exponential, replacing each matrix element x with 10^x.
  • array-bintofreq Upon receiving a bang, array-bintofreq converts every value in the currently referenced array from an FFT bin index to a frequency in hertz.
  • float24 float24 concatenates float-fragment arguments to produce a 23-bit floating-point value.
  • tab_upsample tab_upsample upsamples data from a source table into a destination table, with its creation arguments specifying src, dst, and an upsampling factor of 3.
  • list.integrator list.integrator adds each input list to the previously stored list and outputs the newly integrated list.
  • matrix.sinh matrix.sinh computes the hyperbolic sine of each element in a matrix and outputs a new matrix.
  • ls.mode ls.mode finds the mode—the most frequent element—of a list.
  • math.lgamma~ math.lgamma~ computes the natural logarithm of the absolute value of the gamma function for an input signal.
  • fd_corr fd_corr calculates the Pearson correlation coefficient between two arrays, providing a vanilla Pd equivalent of timbreID’s tabletool “corr” method.
  • mtx_mean mtx_mean calculates the mean value of each column in an input matrix for matrix statistics.
  • matrix_mul_stat~ matrix_mul_stat~ multiplies a multichannel input signal vector by a static matrix, producing an output signal vector (SIG_OUT = A * SIG_IN) without interpolation.
  • rational.to_float rational.to_float converts rational data to a floating-point value.
  • conv.semi2ratio conv.semi2ratio converts an interval in semitones into its corresponding frequency ratio.
  • bitnot~ bitnot~ performs a bitwise NOT operation (one's complement) on an incoming signal.
  • pdp_sign pdp_sign gets the sign of its input, producing values represented as -1 or 1.
  • matrix.hist matrix.hist produces a matrix containing histogram counts for each column of an input matrix.
  • conv.rad2phase~ conv.rad2phase~ converts an input signal value from radians to phase, outputting the converted value.
  • increment tof/increment is a control-rate counter that stores and increments a number, then outputs it as a float.
  • pdp_sthresh pdp_sthresh applies a soft threshold to its input: values between −t and t become 0, values below −t are shifted by +t, and values above t are shifted by −t.
  • curve_sigmoide curve_sigmoide appears to shape values according to a sigmoid curve, for use in nonlinear mappings.
  • trans-lin trans-lin maps an integer received at its left inlet to a linear transition between a start and end value.
  • mtx_diegg mtx_diegg creates a turned diagonal (anti-diagonal) matrix and can obtain the turned diagonal of an input matrix.
  • sigmoid sigmoid applies a sigmoid weighting curve to a list of numbers and outputs the weighted list.
  • vmax vmax finds the maximum value in a list of floats and outputs it as a float.
  • rational.add rational.add adds two rational numbers and outputs the result as Rational data.
  • list_sum list_sum calculates the sum of the elements in a list, with support for a maximum length and a wrap value.
  • pb_int64_to_float pb_int64_to_float converts a decimal-integer symbol, such as a 64-bit field emitted by pb_decode, to a Pd t_float; float input passes through unchanged.
  • zl The zl object is a versatile Pure Data list processor that performs various operations on incoming lists based on its selected mode.
  • math.acos~ math.acos~ computes the principal value of the arc cosine for an input signal and outputs the result as a signal.
  • cusp~ cusp~ is a chaotic signal generator that implements the difference equation y[n] = a - b * sqrt(abs(y[n-1])).
  • math.erf~ math.erf~ computes the error function for an input signal, with relevance to normally distributed random variables in statistics.
  • fblock fblock computes block-relative frequencies, primarily for block-synchronous spectral-domain processing.
  • hann~ The hann~ object applies a Hann window to an incoming audio signal.
  • array-rmstodb Upon receiving a bang, array-rmstodb converts every value in the currently referenced array from RMS to dB amplitude units.
  • mtx_pinverse mtx_pinverse calculates the inverse of a square matrix using pivoting.
  • matrix.median_col matrix.median_col calculates the median value of each column in a matrix.
  • bpm The bpm object calculates conversions to and from beats per minute (BPM).
  • math.atan~ math.atan~ computes the arc tangent of each input signal value and outputs the result as a signal.
  • list-mult list-mult subtracts two lists element by element for control-list processing.
  • matrix.asin matrix.asin computes the arcsine of each element in a matrix and outputs a new matrix.
  • geom geom outputs the nth member of a geometrical row, using a value and proportional factor q.
  • ihisto ihisto builds an integer histogram and reports the peak value and its frequency.
  • hsv2rgb The hsv2rgb object converts color values from the Hue, Saturation, Value (HSV) color space to the Red, Green, Blue (RGB) color space.
  • mtx_phon_curve mtx_phon_curve calculates a phon curve at frequencies supplied as a row or column matrix, outputting the corresponding curve values in dB.
  • value-- value-- provides a post-decrement operator as shorthand for working with a Pd value.
  • array.stddev array.stddev calculates the standard deviation of the values in a named array.
  • turntorad~ turntorad~ converts a signal representing turns into radians.
  • speed The speed object in Pure Data enables dynamic tempo changes, such as accelerando or ritardando.
  • distance-euclidean distance-euclidean calculates the Euclidean distance between two lists, outputting the result as a float.
  • fluid.gain~ The fluid.gain~ object controls the amplitude of an audio signal.
  • array.mean array.mean calculates the arithmetic mean of the values in a named array and outputs the result.
  • db2rms db2rms converts a dB value to an RMS value.
  • scale2freq The scale2freq object converts a scale defined by a list of cents values into a list of frequencies (in Hz).
  • fd_sinh fd_sinh is a hyperbolic-function wrapper that outputs the hyperbolic sine of a float input.
  • ls.max ls.max finds the greatest element in a list.
  • a.sum The a.sum object in Pure Data sums the last x numbers of an array.
  • spherical2cartesian spherical2cartesian converts spherical coordinates (r, phi, theta) into Cartesian coordinates (x, y, z).
  • rgb2hsv The rgb2hsv object converts color values from the RGB (Red, Green, Blue) color space to the HSV (Hue, Saturation, Value/Luminance) color space.
  • vvconv smlib/vvconv convolves two vectors represented as lists of floats and outputs the resulting convolution as a list.
  • mtx_mul mtx_mul performs matrix multiplication and outputs the resulting matrix.
  • catch_extremum catch_extremum returns the most recent local minimum and maximum from incoming data.
  • gcd The gcd object calculates the greatest common divisor (GCD) of two or more numbers.
  • tab_max_index tab_max_index calculates the maximum element in a source array and outputs both its value and index when it receives a bang.
  • mtx_qr mtx_qr calculates the QR decomposition of an input matrix using GSL, producing matrices Q and R such that A = Q * R.
  • diag~ diag~ implements a diagonal state-space system, treating each input DSP block as a set of parallel signals whose states are updated using the documented coupled equations.
  • math.cos~ math.cos~ computes the cosine of an input signal, with input values interpreted in radians.
  • fd_jumpv fd_jumpv calculates the absolute difference between the extreme values in an incoming sequence, producing its “jump value.” For example, values reflecting between -10 and 10 produce a difference of 20..
  • itov itov converts a binary class index to a scaled value using the first-class value, last-class value, and number of classes supplied as arguments.
  • lin2db The lin2db object converts a linear amplitude value to its equivalent decibel full scale (dBFS) representation.
  • vdbtorms vdbtorms converts dB values to RMS values across a vector.
  • list-mean list-mean calculates the arithmetic mean of the floats in a list by dividing their sum by the number of floats, and outputs the result as a float.
  • lexpr lexpr evaluates Lua-syntax expressions using named inlet variables, supporting numeric or symbol inputs and multiple outlets through comma-separated expressions.
  • conv.car2pol conv.car2pol converts a list containing Cartesian x and y coordinates into a radius-and-angle pair, with the angle expressed in radians.
  • exponential_curve exponential_curve curves an input range using a double-exponential function, producing a mapped output in the 0-to-1 range.
  • matrix.exp matrix.exp computes the element-wise base-e exponential, e^x, of a matrix and outputs a new matrix.
  • matrix.randn matrix.randn generates a matrix of random values using a zero-centered Gaussian distribution.
  • ratio2intv ratio2intv converts a ratio into an interval.
  • ms2samps The ms2samps object is a simple abstraction that converts a time value in milliseconds to the equivalent number of audio samples.
  • runningmean runningmean outputs the running mean of the last n floats received by its left inlet, recalculating the mean for each incoming float; a bang outputs the current mean.
  • harmonicity The harmonicity object calculates Clarence Barlow's harmonicity measure for a given interval p/q.
  • conv.bpm2sec conv.bpm2sec converts a frequency expressed in beats per minute (BPM) to its period in seconds.
  • list.histogram list.histogram outputs the distribution histogram of an input list or mlist as a list of probabilities whose length equals the number of bins.
  • fdm fdm is an accumulator that performs either addition or multiplication, outputting the accumulated sum or product for each float input.
  • simplified_quadratic simplified_quadratic curves a raw input range using a simplified quadratic mapping, producing a curved control output.
  • deg2rad The deg2rad object converts degree values (0 to 360) to their equivalent radian values.
  • keepMax keepMax outputs the largest number received since initialization.
  • list.distribution list.distribution calculates the value distribution of an input list or mlist, outputting pairs whose first element is a value and whose second is its count or weight.
  • array.rms array.rms calculates the root mean square (RMS) value of a named array.
  • delta delta calculates and outputs the first- or second-order difference between control values, making it useful for analyzing changes in a numeric stream.
  • drunkard The drunkard object generates a sequence of pseudo-random numbers by simulating a random walk.
  • mtx_spherical_radial mtx_spherical_radial calculates spherical radials from a matrix of coordinates and outputs the result as a matrix.
  • atanh~ The atanh~ object calculates the hyperbolic arc-tangent of an incoming signal.
  • vlmin vlmin finds the minimum value in a list of floats and its location in the list, outputting both as floats.
  • greaterthaneq~ The greaterthaneq~ (or >=~) object performs a "greater than or equal to" comparison for audio signals.
  • hid_cuberoot hid_cuberoot maps a float input range to a cube-root curve, converting hid values in the 0-to-1 range.
  • diff_n diff_n differentiates a float input, providing a control-rate measure of its change.
  • tab_sqrt tab_sqrt copies the square root of each value from a source array to a destination array and outputs a bang when finished.
  • rational.mul rational.mul multiplies rational numbers and outputs the result as Rational data.
  • conv.lin2curve conv.lin2curve maps float values or lists from an assumed linear input range to a curved, exponential output range while allowing zero.
  • list-abs list-abs applies the absolute-value operation to the float elements of an input list and outputs the resulting list.
  • intv2ratio intv2ratio converts an interval into a ratio.
  • conv.lin2lin conv.lin2lin converts input floats or lists from one linear range to another and outputs the converted float or list.
  • rint The rint object rounds floating-point numbers to the nearest integer value.
  • fd_round fd_round rounds an incoming stream of floats and outputs the rounded values.
  • pdp_cheby pdp_cheby approximates a mapping function over the range −1 to 1 using Chebyshev coefficients.
  • array-rerange array-rerange proportionally scales every value in the currently referenced array to fit between specified lower and upper limits, inclusive.
  • vvminus vvminus subtracts a list of floats—or a single float—from a list, outputting the resulting list of floats.
  • array-pow Upon receiving a bang, array-pow raises every value in the currently referenced array to the specified power.
  • math.log2 math.log2 computes the base-2 logarithm of an input value.
  • ls.min ls.min outputs the smallest element of an input list.
  • matrix.det matrix.det computes the determinant of a square matrix and outputs the result as a float.
  • pix_add The pix_add object combines two input images of the same size by adding their pixel values.
  • radtoturn~ radtoturn~ converts an input signal expressed in radians to turns.
  • constant constant outputs the value of the mathematical constant pi, 2pi, or e as a float when it receives a bang.
  • pb_int64_mod pb_int64_mod parses a decimal-integer symbol, or truncates a float to int64, then computes its mathematical modulus N and outputs a float in the range [0, N).
  • matrix.randu matrix.randu generates a matrix of random values with a uniform distribution over [0, 1].
  • fd_fletcher-munson fd_fletcher-munson calculates amplitude compensation from the Fletcher–Munson curve for a supplied frequency, producing the result in RMS or decibels.
  • curvesmap curvesmap maps values from a specified input range to a specified output range using any curve supported by curves.
  • hz2rad The hz2rad object converts a frequency in Hertz (Hz) to radians per sample.
  • hex2dec The hex2dec object converts hexadecimal values to their decimal equivalents.
  • ___quantizer__ _quantizer takes a control-voltage signal and quantizes it to intervals in a selected scale, outputting the resulting quantized voltage.
  • complex.log complex.log computes the complex natural logarithm, with branch cuts as indicated in the help patch.
  • quantize quantize rounds an input number to the next multiple of its argument.
  • cmplxsqrt~ cmplxsqrt~ calculates the square root of a complex signal, outputting the real and imaginary parts of the result.
  • samps2ms The samps2ms object is a simple utility that converts a time value from samples to milliseconds.
  • pol2cart The pol2cart object converts 3D polar coordinates (radius r, azimuthal angle phi, and polar angle theta) into Cartesian coordinates (x, y, z).
  • mtx_egg mtx_egg creates an exchange matrix, described as a turned identity matrix.
  • cuadratic cuadratic iterates the quadratic recurrence x1 = x² + c, outputting the current y value for a step or N iterations as a list of (y, n).
  • round The round object approximates input numbers (floats or lists) to the nearest integer multiple of a specified value.
  • doubledelta doubledelta computes the delta and the delta-of-delta of incoming values, providing the results through two float outlets.
  • fmod~ fmod~ provides the fmod operation from math.h for Pd signals.
  • tab_complex_mul tab_complex_mul multiplies two complex-valued array sources, each represented by separate real and imaginary arrays, and writes the result to separate real and imaginary destination arrays.
  • complex.pow complex.pow raises a complex number to a complex power and outputs the result as Complex data.
  • vvplus vvplus adds two lists of floats and outputs the resulting list.
  • cents2scale cents2scale converts a list of intervals expressed in cents into a musical scale represented by semitone steps.
  • cosh The cosh object calculates the hyperbolic cosine of a given floating-point number.
  • speedlimiter+ speedlimiter+ is a control-rate filter abstraction that limits positive variation in an incoming float to its argument for each sample.
  • rossler rossler calculates Rössler’s attractor and outputs its evolving values, providing a chaotic dynamical system for Pd patches.
  • array.hist array.hist calculates a histogram for a named array and outputs the bin values as a list whose length equals the number of bins.
  • conv.pol2car conv.pol2car converts polar coordinates to Cartesian coordinates.
  • rdiv rdiv performs division, similar to the [/] object, but with reversed inlet functionality.
  • matrix.clip matrix.clip clips every value in a matrix to the range [min, max] and outputs a new matrix.
  • matrix.matmul matrix.matmul computes the matrix product of two matrices and outputs the result as a Matrix.
  • fwarp fwarp warps an input frequency using the formula out = tan(2π·in/sr) · (sr/2π).
  • pi The pi object calculates and outputs the mathematical constant pi, optionally multiplied by a float value provided as an argument or via its second inlet.
  • matrix_diag_mul_stat~ matrix_diag_mul_stat~ multiplies an n-dimensional input signal vector by a dynamic diagonal n×n signal matrix, producing an n-dimensional output signal vector without interpolation.
  • exponential_seat exponential_seat curves an input in the 0-to-1 range using a double-exponential function, producing a control value in the 0-to-1 output range.
  • max~~ max~~ performs a double-precision comparison and outputs the greater value.
  • gbman~ gbman~ is a chaotic audio generator based on the gingerbread man map difference equation, y[n] = 1 + abs(y[n-1]) - y[n-2].
  • frac2dec The frac2dec object converts fractional representations (e.g., "1/2", "3/4") into their corresponding decimal floating-point numbers.
  • array-clip Upon receiving a bang, array-clip limits every value in the referenced array to the lower and upper bounds specified at creation.
  • asinh The asinh object calculates the hyperbolic arc-sine of a given floating-point number.
  • complex.imag complex.imag extracts and outputs the imaginary part of a complex number as a float.
  • degrees2mapping degrees2mapping converts degree values into the mapping range for use with mapping controls and abstractions.
  • mtx_logspace mtx_logspace creates a logarithmically spaced matrix vector from a start value to a stop value with a specified number of entries.
  • math.asin~ math.asin~ computes the principal value of the arc sine for an input signal and outputs the result as a signal.
  • rational.sub rational.sub subtracts rational numbers and outputs the result as Rational data.
  • triple-scale triple-scale linearly interpolates between two points represented as three-value (x, y, z) lists, providing a control-rate list output.
  • iso226 The iso226 object generates a list of 29 decibel (dB) values across a frequency range, corresponding to equal-loudness contours.
  • quantize~ The quantize~ object quantizes an incoming audio signal to a variable number of steps.
  • conv.phase2rad~ conv.phase2rad~ converts a signal-rate phase value in the range 0–1 to radians in the range 0–2π.
  • midi2freq The midi2freq object converts MIDI note numbers into their corresponding frequencies in Hertz.
  • circular circular curves a float input using a double-circular mapping, producing a float output in the range 0 to 1.
  • jit_expr The jit_expr package provides a just-in-time compiled family of expression evaluators: jit/expr processes control data, while jit/expr~ and jit/fexpr~ process audio signals.
  • matrix.div matrix.div performs element-wise division of a matrix by either a divisor matrix or a float, outputting the resulting Matrix.
  • fd_cauchy fd_cauchy computes the Cauchy distribution, using the formula t/(π(t²+x²)).
  • math.acosh~ math.acosh~ computes the principal value of the hyperbolic arccosine for an input signal.
  • vlrange vlrange computes a leaky maximum minus a leaky minimum for incoming floats or lists of floats, producing a float or list of range values.
  • complex.abs complex.abs computes the magnitude of a complex number and outputs it as a float.
  • expr expr evaluates mathematical expressions on control data.
  • deltas deltas generates a list of differences between values in an input float stream.
  • ceil The ceil object is a mathematical function that rounds a number up to the nearest integer.
  • pdf~ The pdf~ object calculates the probability density function of an incoming signal.
  • math.pi~ math.pi~ outputs the mathematical constant π as a signal, optionally multiplied by a factor.
  • cmplxadd~ cmplxadd~ adds two complex numbers and outputs the real sum from its first outlet and the imaginary sum from its second.
  • sinh The sinh object calculates the hyperbolic sine of a given floating-point number.
  • ucmod~ ucmod~ is a unit circle modulator implementing the expression (1 + r·conj(z)) / (1 + r·z).
  • fd_lspace fd_lspace normalizes the distance of a Lorenz system and is intended to be cloned.
  • blunt blunt provides assertive number and operator objects, including arithmetic forms that use prefix notation.
  • matrix.range_row matrix.range_row computes each matrix row’s range, defined as the difference between that row’s maximum and minimum values.
  • resonant~ The resonant~ object is a bandpass resonator filter that allows for control over its center frequency and resonance.
  • array-median Upon receiving a bang, array-median outputs the median value of the currently referenced array from its first outlet.
  • degtorad~ degtorad~ converts a signal representing degrees into radians.
  • array-maxk array-maxk returns the k largest values in the currently referenced array as a list from its first outlet.
  • list.rundiff list.rundiff computes the adjacent differences of an input list, producing a result list whose first element equals the first input element and whose subsequent elements are each the current input minus the preceding input.
  • cxmean cxmean calculates the mean of the values in a named array and outputs the result as a float.
  • math.floor math.floor returns the largest integral value not greater than its input, providing a floor operation for numeric values.
  • scale7 scale7 is a control abstraction for mapping values to an arbitrary seven-tone scale.
  • vmin vmin finds the minimum in a list of floats and outputs both the minimum value and its location in the list.
  • mtx_minmax mtx_minmax finds the minimum and maximum values of an input matrix.
  • tab_rmstodb tab_rmstodb calculates RMS-to-decibel values from a source array and writes them to a destination array when it receives a bang.
  • clip~ The cyclone/clip~ object constrains an input audio signal to a specified minimum and maximum range.
  • math.mul math.mul multiplies a float, or each numeric value in a list, by a stored multiplicand; non-float list values are ignored.
  • lornorm lornorm computes the Lorenz equations and is described as related to lorenz, but the patch does not provide enough text to explain the difference between them.
  • frac2cents The frac2cents object converts fractional interval values into cents.
  • db2phon The db2phon object converts a decibel (dB) value into phons, a unit representing perceived loudness.
  • matrix.acosh matrix.acosh computes the element-wise inverse hyperbolic cosine of a matrix and outputs a new matrix.
  • list-stddev list-stddev calculates the standard deviation of a list of floats.
  • mtx_cumsum mtx_cumsum computes the cumulative sum of a matrix in the row or column direction, making it useful for numerical integration or generating ascending number sequences.
  • n amb/n calculates an ambisonic channel count from a specified order.
  • list-round list-round rounds all numbers in an input list to the nearest multiple of a specified value and outputs the resulting list.
  • mtx_powtodb mtx_powtodb converts each power value in an input matrix to Pd-style decibels and outputs a matrix.
  • mtx_eig mtx_eig computes the complex-valued eigenvalues of an input matrix and, when requested, its eigenvectors.
  • link The link object calculates forces between two masses, simulating a physical connection with configurable rigidity and damping.
  • mtx_linsweep mtx_linsweep creates an n-sample linear sweep matrix spanning specified start and stop digital frequencies.
  • operatord~ operatord~ is like operator~, but it accepts a phasor~ signal at its inlet.
  • math.cbrt math.cbrt computes the cube root of an input value.
  • ln~ ln~ operates on a signal in the same way as log~.
  • mtx_rmstodb mtx_rmstodb converts each element of a matrix from a linear RMS value to Pd-style decibels.
  • mtx_binops mtx_binops represents iemmatrix’s binary matrix arithmetic objects for addition, subtraction, matrix or element-wise multiplication, element-wise division, and element-wise power.
  • pmpd2d The pmpd2d object implements a 2D mass-spring-damper physical model, designed for particle-based simulations in Pure Data.
  • chair.speed chair.speed measures how fast position coordinates are changing.
  • 1scomp 1scomp gives the one’s complement of a number.
  • math.inf math.inf outputs an IEEE 754 positive infinity (inf) value, which cannot be represented accurately as a finite floating-point number.
  • matrix.mul matrix.mul performs element-wise multiplication of two matrices and outputs the resulting matrix.
  • list.delta list.delta outputs a delta list representing the difference associated with the current input list of floats.
  • tdh.math.lin2dbfs tdh.math.lin2dbfs converts a linear gain value to decibels relative to full scale (dBFS).
  • float2bits The float2bits object converts a decimal floating-point number (IEEE754 single precision) into its binary representation.
  • fd_blackman fd_blackman computes the y value of a generalized Blackman window, intended to minimize side-lobe levels by adding shifted sinc functions.
  • reverb-calculator reverb-calculator calculates delay times in milliseconds for a reverb setup from room dimensions in meters and a decay percentage.
  • v2db v2db converts an input value to an output level in dB.
  • matrix.mean_col matrix.mean_col computes the mean value of each column in a matrix and outputs the results as a one-row Matrix vector.
  • matrix.stddev_col matrix.stddev_col calculates the standard deviation of the values in each matrix column and outputs the results as a one-row matrix.
  • complex.!= complex.!= checks whether two complex numbers are unequal, outputting 1 when they differ and 0 otherwise.
  • elliptic_seat elliptic_seat curves a control input using a double-linear mapping, producing output in the range 0 to 1.
  • fluid.mfcc~ The fluid.mfcc~ object calculates Mel-Frequency Cepstral Coefficients (MFCCs) in real-time, serving as a classic timbral audio descriptor.
  • halton halton computes a Halton sequence, producing each sequence value as a float from its float input.
  • math.pi math.pi outputs the mathematical constant π, optionally multiplied by a factor.
  • e The e object calculates and outputs the mathematical constant 'e' (Euler's number).
  • j.map j.map maps incoming values according to a selectable mapping function, such as exponential or tanh.
  • mtx_min2 mtx_min2 computes the element-wise minimum of two matrices, for matrix comparison at control rate.
  • log10 log10 returns the base-10 logarithm of its input.
  • asin~ The asin~ object calculates the arc-sine of each input audio sample.
  • matrix.atan matrix.atan computes the element-wise arctangent of a matrix, producing a new matrix.
  • math.atanh math.atanh computes the inverse hyperbolic tangent of an input value.
  • matrix_diag_mul_line8~ matrix_diag_mul_line8~ multiplies an n-dimensional signal vector by a dynamically changeable diagonal n×n matrix, producing an n-dimensional output vector.
  • ++value ++value provides a pre-increment operator for a named Pd value.
  • binlist binlist converts a numeric value into a list of binary digits, providing a bitwise representation of the value.
  • matrix.rank matrix.rank computes the rank of a matrix and outputs it as an integer.
  • fd_hopmsec fd_hopmsec converts an input duration in milliseconds to the required hop or block size in samples, using the current patch’s sample rate from samplerate~.
  • gmean The gmean object generates a list of numbers that form a geometric progression between a specified start and end value.
  • eqdiv The eqdiv object generates equal temperament scales.
  • delta~ The delta~ object calculates the difference between the current incoming audio sample and the previous sample.
  • rms2db rms2db converts an RMS value to decibels (dB).
  • trunc~ trunc~ truncates an incoming audio signal towards zero, effectively retaining only the integer part of each sample.
  • ls.nearest ls.nearest iteratively searches a list for the number nearest to a target value.
  • matrix.stddev matrix.stddev calculates the standard deviation of matrix values and outputs it as a float.
  • fd_mult fd_mult performs accumulated multiplication of float values received at its first inlet and outputs the accumulated product as a float.
  • max__ max__ compares two double-precision numbers and outputs the greater value, with 15-digit accuracy.
  • transpose~ transpose~ computes 2^(in/12), converting its input into a transposition ratio based on 12 steps per doubling.
  • curvesmap~ curvesmap~ is a signal-rate abstraction that maps an input range to an output range using curve types supported by curves~.
  • math.atan math.atan computes the principal value of the arc tangent of an input value.
  • rounding rounding illustrates three ways to convert fractional values: floor rounds down, ceil rounds up, and int gravitates toward zero.
  • hid_invert hid_invert inverts a stream of numbers, providing a control abstraction for reversing numeric input values.
  • minmax~ The minmax~ object continuously tracks the minimum and maximum amplitude values of an incoming audio signal.
  • int-or-float int-or-float optionally converts incoming numbers to integers and is mainly intended for converting Max patches; its default mode is integer.
  • rounder~ rounder~ rounds incoming signal values to an arbitrary precision and outputs the rounded signal.
  • array.sum array.sum calculates the sum of all values in a named array and outputs the result.
  • cadd~ cadd~ performs complex addition on signal inputs.
  • clip The clip object (or cyclone/clip~) constrains incoming float or list values to a specified numerical range.
  • mean The mean object calculates a running or moving average of all received numbers.
  • hid2rad hid2rad converts control values from the hid range into radians.
  • mov.avg The mov.avg object calculates a running or moving average of incoming float values.
  • lmax lmax computes a leaky maximum from incoming float values and outputs the result as a float.
  • fd_exp fd_exp computes the exponential-distribution probability density f(x) = λe^(-λx), for modeling the time or distance between events.
  • math.approx math.approx checks whether an input value is approximately equal to a comparison pattern by testing whether |x − pattern| ≤ |epsilon|, outputting 1 when the test succeeds.
  • div__ div__ performs double-precision division.
  • pong The pong object limits input values by folding, wrapping, or clipping them within a specified low-high range.
  • pdp_mul pdp_mul multiplies two packets.
  • matrix.cos matrix.cos computes the element-wise cosine of an input matrix and outputs a new matrix.
  • matrix.transpose matrix.transpose transposes a Matrix, exchanging its rows and columns, and outputs the transposed Matrix.
  • autoscale autoscale scales a stream of numbers to an output range, with examples using ranges such as 0–1 and −0.01–0.01.
  • addl~ addl~ performs signal addition using a line~-style interpolator for the addition value.
  • fd_array-rerange fd_array-rerange remaps the elements of a named array to a new range.
  • scaler scaler converts numbers into musical notes expressed as frequencies.
  • center_point center_point converts normalized 0-to-1 control data, such as joystick input, into data organized around a center point.
  • list.convolve list.convolve calculates the convolution of two lists and outputs the result.
  • minus minus performs chained subtraction, outputting the result as inlet 0 minus the values in the other inlets.
  • math.sinh~ math.sinh~ computes the hyperbolic sine of an input signal, using sinh(x) = (eˣ − e⁻ˣ)/2.
  • ms2sec ms2sec converts a time value in milliseconds to seconds and provides a rounded result.
  • mtx_rot mtx_rot produces a two-dimensional Cartesian rotation matrix for use in matrix-based control processing.
  • mass3D The mass3D object simulates a mass in a 3D space, calculating its position and velocity based on applied forces, weight, damping, and boundary conditions.
  • mtx_rotx mtx_rotx creates a three-dimensional Cartesian rotation matrix for rotation around the x-axis.
  • quantizer~ The quantizer~ object quantizes an incoming signal to discrete step values, offering five different approximation modes including round, truncate, floor, and ceil.
  • math.exp2~ math.exp2~ computes the base-2 exponential, 2**x, for each value of an input signal and outputs the result as a signal.
  • matrix.solve matrix.solve solves a system of linear equations of the form A*X = B and outputs the result X as a Matrix.
  • mtx_conv mtx_conv performs two-dimensional convolution of an input matrix with a filter-matrix kernel, providing 2D FIR filtering and outputting the resulting matrix.
  • ramp~ The ramp~ object generates a linear signal ramp between user-defined minimum and maximum values, automatically looping or clipping based on its mode.
  • mtx_cinverse mtx_cinverse computes the inverse of a complex-valued matrix.
  • curve_log curve_log maps a float input in the 0-to-1 range onto a logarithmic curve, producing a float output in the same 0-to-1 range.
  • fadtodb fadtodb converts a fader-scale value to MIDI dB.
  • tab_complex_inv tab_complex_inv inverts complex values from separate real and imaginary source arrays into separate real and imaginary destination arrays.
  • fd_cubic fd_cubic generates a pseudo-cubic curve using f(x) = (x³ + 3x² − 6x − 8) / 4.
  • list.range list.range outputs a two-element list containing the smallest and largest values from an input list or mlist.
  • list-clip list-clip clips lists, serving as the list-oriented counterpart to clip.
  • rover~ rover~ performs signal division like /~, but with the inlet roles reversed.
  • hid_cube hid_cube maps a float input in the hid output range of 0 to 1 onto a cubic curve, producing a float output.
  • --v --v is a shorthand for --value.
  • tCylinder3D The tCylinder3D object defines a 3D cylindrical volume and tests if a given 3D point (referred to as a "mass") is located within its boundaries.
  • rgb2yuv The rgb2yuv object converts color values from the RGB (Red, Green, Blue) color space to the YUV (Luma, Chroma) color space.
  • divmod divmod calculates integer division and modulo for a dividend and divisor, outputting the quotient and remainder.
  • tab_min_max tab_min_max calculates the minimum and maximum element values in a source table when it receives a bang.
  • fd_expo~ fd_expo~ is the same as fd_expo, but uses DSP to store its output in an array, and is used by fd_windows.
  • clock The clock object sends bangs at a regular tempo, acting as a 'main' clock or a 'synced' clock.
  • array-integrate Upon receiving a bang, array-integrate cumulatively sums the values in the currently referenced array, so each new element equals the sum of that element and all preceding elements.
  • sin~ The sin~ object generates a sine wave by calculating the sine of its signal input, scaled by two pi.
  • vabs vabs computes the absolute value of each float in an input list and outputs the resulting list.
  • conv.lin2exp conv.lin2exp maps float values or lists from a specified linear input range to an exponential output range, producing converted values.
  • coordinates The cart2pol, pol2sph, sph2cart, cart2sph, pol2cart, and sph2pol objects convert between Cartesian, Polar, and Spherical coordinate systems.
  • tab_dbtopow tab_dbtopow calculates decibel-to-power values from a source array and writes them to a destination array when it receives a bang.
  • complex.log10 complex.log10 computes the common (base-10) logarithm of a complex number and outputs the result as Complex data.
  • array-range array-range returns the range of the currently referenced array when it receives a bang.
  • matrix.median_row matrix.median_row computes the median value for each row of an input matrix.
  • track_max track_max tracks the maximum float value it receives and outputs a float.
  • complex.conj complex.conj computes the complex conjugate of a complex value and outputs the result as Complex data.
  • lorenz lorenz calculates the Lorenz attractor and outputs its X, Y, and Z values.
  • math.lgamma math.lgamma computes the natural logarithm of the absolute value of the gamma function.
  • logistic~ logistic~ is a chaotic signal generator based on the logistic difference equation.
  • wrap2 The wrap2 object wraps an input value within a specified minimum and maximum range.
  • addNoise addNoise takes a number and adds a random number to it, providing a simple way to introduce noise into numeric values.
  • matrix.sign matrix.sign applies the signum function element-wise to a matrix and outputs a new matrix.
  • math.cosh~ math.cosh~ computes the hyperbolic cosine of an input signal and outputs the result as a signal.
  • amean The amean object generates a list of arithmetic means.
  • conv.amp2dbfs conv.amp2dbfs converts amplitude values to decibels full scale (dBFS), accepting either a float or a list and outputting the converted value.
  • flt.a-weight flt.a-weight converts input frequencies in hertz to A-weighting values, for applying the frequency-dependent A-weighting curve.
  • vdelta vdelta computes the element-wise difference between consecutive input vectors, outputting each current value minus the corresponding previous value.
  • matrix.stddev_row matrix.stddev_row calculates the standard deviation of the values in each matrix row and outputs the results as a column matrix.
  • math.asin math.asin computes the principal value of the arc sine function.
  • rescale The rescale object maps input values from one numerical range to another, allowing for linear, exponential, or logarithmic scaling.
  • mtx_inverse mtx_inverse calculates the inverse of a square matrix, for which multiplying the input and inverse in either order yields the identity matrix.
  • unity unity generates the non-continuous Unity attractor, producing X and Y values when driven by a metro.
  • atan~ The atan~ object calculates the arc-tangent of each incoming audio sample.
  • fader~ The fader~ object is a signal waveshaper designed for crossfading and amplitude modulation.
  • array-seq array-seq creates an arithmetic sequence in an array, with controls for its multiplier and vertical offset.
  • mod~ mod~ performs a modulo operation on two signals, outputting the remainder of the dividend divided by the divisor.
  • math.abs math.abs computes the absolute value of a float input.
  • lstd lstd calculates a leaky standard deviation from incoming floats, using a decaying accumulator for control-rate filtering.
  • interpolate The interpolate object smoothly transitions between a start value (or list of values) and a target value (or list of values) based on an input float between 0 and 1.
  • matrix.abs matrix.abs calculates the absolute value of each element in a matrix and outputs a new matrix.
  • floor The floor object implements a standard mathematical floor function, rounding a given number down to the nearest integer.
  • op~ The op~ object performs various signal operations, including comparative, logical, bitwise, and modulo calculations.
  • conv.samp2ms~ conv.samp2ms~ converts an input signal representing sample counts into an output signal in milliseconds, using the current sample rate.
  • velocity velocity measures the velocity of incoming numeric values in digits per second.
  • deadzone deadzone converts all input values within the range −N through 0 to N.
  • matrix.sub matrix.sub performs element-wise subtraction on matrices, taking the minuend matrix in its first inlet and a subtrahend matrix or float in its second inlet.
  • mtx_pivot mtx_pivot pivot-transforms a matrix by rearranging its rows and columns so that maximum values lie on the diagonal, with the matrix maximum at the upper-left corner.
  • matrix.trunc_exp matrix.trunc_exp computes the element-wise base-e exponential of a matrix, truncating values to avoid infinity.
  • db2lin The db2lin object converts amplitude values from decibels full scale (dBFS) to a linear scale.
  • conv.int2bits conv.int2bits converts an integer input into a list of bits.
  • mtx_trace mtx_trace calculates the trace of an input matrix, defined as the sum of its diagonal elements.
  • logistic_sigmoid logistic_sigmoid curves a float input using a double-exponential, producing a float output mapped from 0 to 1.
  • shadylook shadylook maps input values between 0 and 1 through a named curve: gauss, cauchy, or rexp.
  • fd_gauss~ fd_gauss~ computes the same Gaussian function as fd_gauss and stores it into a named array via DSP; it is used by fd_windows and has no outlets.
  • complex.norm complex.norm computes the squared magnitude of complex data and outputs it as a float.
  • notedur2ratio The notedur2ratio object converts symbolic musical note durations (e.g., 4n for a quarter note) into numerical ratios, outputting them as either fractions or floats.
  • pdp_xor pdp_xor performs a bitwise XOR operation on PDP data.
  • array-mean array-mean returns the arithmetic mean of the currently referenced array when it receives a bang.
  • sqr sqr squares a control signal.
  • dbtofad dbtofad converts MIDI dB values to a fader-scale representation.
  • fd_ceil fd_ceil is an abstraction that applies a C-style ceiling function to incoming floats.
  • rad2deg The rad2deg object converts an input value from radians to degrees.
  • multiline~ The multiline~ object performs line-interpolated multiplication of multiple input signals.
  • matrix.accu matrix.accu accumulates a matrix by summing all of its elements.
  • polyfun The polyfun object evaluates a polynomial function.
  • norm norm normalizes a stream of floats with an initially unknown range into values from 0 to 1, adapting the normalized range over time.
  • one2four one2four is a control abstraction that performs a simple one-to-four mapping, producing four float outputs.
  • cmplxabs~ cmplxabs~ calculates the absolute value (magnitude) of a complex number.
  • mtx_polyval mtx_polyval evaluates a polynomial with given coefficients at specified values of x.
  • expr_scale expr_scale scales an input value from one numeric range to another, with creation arguments specifying input low/high and output low/high values (for example, 0–9 to 100–255).
  • matrix.mean matrix.mean computes the mean value of a matrix and outputs it as a float.
  • cmplxmult~ cmplxmult~ multiplies two complex numbers and outputs the real product from its first outlet and the imaginary product from its second.
  • rec2pol~ rec2pol~ converts two signal inputs representing rectangular coordinates into two signal outputs representing polar coordinates, such as converting the sine and cosine outputs of rfft to phase and magnitude.
  • math.inf~ math.inf~ is an infinity signal generator that outputs an IEEE 754 floating-point infinity value.
  • matrix.range_col matrix.range_col computes each matrix column’s range, defined as the difference between its maximum and minimum values.
  • matrix.conv2 matrix.conv2 performs 2D convolution of matrix data with a convolution kernel.
  • dec2frac The dec2frac object converts decimal numbers into their fractional equivalents.
  • factor The factor object takes a float as input and outputs a list of its prime factors.
  • lhist lhist builds a “leaky” histogram from input floats or lists of floats, storing samples across a configurable number of classes.
  • maximum The maximum object outputs the greatest value among two or more numbers.
  • fd_trunc2n fd_trunc2n truncates an input number to a size of 2^n.
  • local_max local_max filters a stream of floats and outputs the value of each local maximum when one occurs.
  • mtx_.cdiv mtx_.cdiv performs element-wise division of two complex-valued matrices.
  • vsum vsum computes the sum of a list of floats for control-rate list processing.
  • tab- tab- provides a short way to decrement values in a Pd table.
  • sum The sum object calculates the sum of a list of floating-point numbers.
  • matrix.tanh matrix.tanh applies the hyperbolic tangent element-wise to matrix data and outputs a new matrix.
  • bark2hz The bark2hz object converts a value from the Bark scale to Hertz.
  • pdp_add pdp_add adds two packets together and saturates the result.
  • list-sub list-sub subtracts two lists element by element, providing a control-rate list operation.
  • rad2hid hid/rad2hid converts a float representing an angle in radians from the range −π to π into HID-oriented numeric output.
  • conv.hex2int conv.hex2int converts hexadecimal symbols to integer values and can process either a single symbol or a list of values.
  • rms~ The rms~ object calculates the Root Mean Square (RMS) value of an incoming audio signal, similar to env~ but providing RMS in linear amplitude or dBFS.
  • math.log10 math.log10 computes the base-10 logarithm of an input value.
  • array-series array-series fills the currently referenced array with a series defined by a message to its first inlet, specifying the starting value, ending value, and exponent.
  • math.sqrt math.sqrt computes the non-negative square root of an input float and outputs the result.
  • matrix.exp2 matrix.exp2 computes the element-wise base-2 exponential, replacing each matrix element x with 2^x.
  • cosh~ The cosh~ object calculates the hyperbolic cosine of an input signal sample by sample.
  • matrix.tan matrix.tan computes the tangent of each element in a matrix and outputs a new matrix.
  • fd_gauss fd_gauss calculates the value of a Gaussian distribution for a given x value, using a mean and standard deviation supplied as its two creation arguments.
  • rand.f The rand.f object generates pseudo-random floating-point numbers within a specified range when triggered by a bang.
  • cmplxdiv~ cmplxdiv~ performs complex division on signal inputs, outputting the real and imaginary parts of the result through separate outlets.
  • math.sync_lshift math.sync_lshift performs a synchronous signed bitwise left shift on an integer value by a specified integer shift amount.
  • threeply threeply generates points for the non-continuous Threeply attractor, with the patch presenting it as a way to find a random attractor set.
  • plot.linspace~ plot.linspace~ outputs a signal containing a specified number of evenly spaced values over a linear interval, intended for use with array.plot~ or ui.plot~.
  • qnorm~ qnorm~ normalizes a quaternion signal to unit norm.
  • modf~ modf~ splits an input signal into its integer and fractional parts.
  • hid_spiral hid_spiral converts Cartesian x/y coordinates, such as joystick axes, into polar radius and angle values.
  • matrix.acos matrix.acos computes the element-wise arccosine of a matrix, producing a new matrix.
  • gaussian gaussian generates a Gaussian curve from float control input.
  • mtx_ones mtx_ones creates a matrix in which every element is 1.
  • math.asinh math.asinh computes the inverse hyperbolic sine of an input value.
  • reflect reflect reflects an incoming float within a range from the negative to the positive range value, optionally adding an offset to the axis of symmetry.
  • wrap2~ The wrap2~ object wraps an input signal's values within a specified low and high range.
  • value++ value++ provides a shorthand post-increment operator for a Pd value.
  • transf_fader transf_fader transforms a slider’s input range using configurable input/output breakpoint pairs.
  • cxavgdev cxavgdev is used to calculate the average deviation of values in a Pd array, complementing cxmean and cxstddev.
  • speedlimiter speedlimiter is a control-rate filter that limits negative variation in a float signal at each sample.
  • curve_circle curve_circle maps an input in the 0–1 range to a circular curve, producing output in the 0–1 range.
  • complex.arg complex.arg outputs the phase angle (argument) of a complex number in radians as a float.
  • ustep~ ustep~ applies a unity step function to an input signal using a configurable threshold.
  • mtx_spivot mtx_spivot permutes a matrix’s rows so that maximum or minimum values lie on the diagonal, although the diagonal remains unsorted.
  • complex.tan complex.tan computes the tangent of a complex number and outputs the result as Complex data.
  • mtx_rotz mtx_rotz creates a 3D Cartesian rotation matrix for rotation around the z-axis.
  • mul__ mul__ performs double-precision multiplication and is equivalent in purpose to *__ and *''.
  • faixa faixa converts an input value from one value range to another and outputs the converted value.
  • speedlimiter- speedlimiter- is a control-rate filter abstraction that limits negative variation in a float signal.
  • curves~ curves~ is the signal-rate version of curves, transforming an input signal with selectable curves such as exponential, bounce, sine, logarithmic, window, and linear range-mapping functions.
  • atodb~ The atodb~ object converts a linear amplitude signal to its equivalent in decibels full scale (dBFS).
  • mtx_cart2sph mtx_cart2sph converts a matrix of Cartesian vectors into spherical coordinates.
  • conv.samp2ms conv.samp2ms converts a number of samples to time in milliseconds according to the sample rate.
  • one2two one2two is a control abstraction that provides simple one-to-two mapping, taking float input and producing two float outputs.
  • ceammc.samp ceammc.samp is a sample counter in the ceammc library.
  • math.sync_sub math.sync_sub performs synchronized subtraction, operating on integers only.
  • degtoturn~ degtoturn~ converts an input signal expressed in degrees to turns and outputs the resulting turn values.
  • array-nearest array-nearest searches its currently referenced array for the value nearest to a query value received at its first inlet.
  • clog~ clog~ computes the complex logarithm of a signal represented by two signal inlets and produces a complex result through two signal outlets.
  • ui.incdec ui.incdec is a UI widget for incrementing or decrementing a numeric value and outputting the result.
  • mtx_roots mtx_roots solves polynomials using eigenvalues via mtx_eig, accepting a matrix of polynomial coefficients such as 1 -2 4 -12 -45 54.
  • math.cosh math.cosh computes the hyperbolic cosine of an input float and outputs the result.
  • mtx_cos mtx_cos computes the cosine of each element in an input matrix and outputs the resulting matrix.
  • list-centroid list-centroid calculates the centroid, or center of mass, of a list using sum(mi * i) / sum(mi), with indices starting at 0.
  • median_3 median_3 outputs the median value of the three most recent float samples.
  • c.incdec c.incdec increments or decrements a stored value without creating a feedback stack, and outputs the resulting value.
  • list-equalize list-equalize scales a list by dividing its float elements by their sum, so those elements sum to 1.
  • particle particle treats each incoming float as a particle in a stream and outputs the stream’s nth-order derivative.
  • fd_geomean fd_geomean calculates the geometric mean of a list of floats and outputs the result as a float.
  • list.sum list.sum calculates the sum of the floats in an input list or mlist and outputs the result as a float.
  • max_n max_n returns the maximum among the last n input values, providing a rolling maximum.
  • parabola parabola iterates the function x1 = (1 - x0) * a * x0, producing an unnormalized output.
  • math.exp math.exp computes the base-e exponential, e^x, of an input value.
  • complex.sub complex.sub subtracts complex numbers and outputs the result as Complex data.
  • fd_map fd_map linearly maps an incoming float from a 0-to-maximum input domain to a specified range and outputs the mapped float.
  • mtx_cmul mtx_cmul performs multiplication of two complex-valued matrices, with each matrix supplied as separate real and imaginary parts.
  • matrix.median matrix.median computes the median value of a matrix and outputs it as a float.
  • tab_dbtorms tab_dbtorms converts dB values from a source array to RMS values in a destination array and outputs a bang when calculation is complete.
  • revbinops revbinops provides binary operators with reversed operand order, including subtraction, division, power, bit shifts, remainder/modulo, and integer division variants.
  • fd_floor fd_floor applies the floor function to an incoming float, outputting a float.
  • fd_arcsin fd_arcsin computes Xenakis’ “arc sin” function, shown as π⁻¹ × (x × (1 − x))⁻¹/², for an input float.
  • mtx_symasym mtx_symasym decomposes a square matrix M into symmetric and asymmetric parts such that M = S + A.
  • array.unop array.unop applies a unary numerical operation or arbitrary one-input abstraction to each value in an input array, storing the results in an output array.
  • recip~ recip~ calculates the reciprocal of each value in an input signal and outputs the resulting signal.
  • math.ceil math.ceil rounds an input to the smallest integral value that is not less than it.
  • hotbinops3 hotbinops3 provides arithmetic and bitwise binary operators with hot inlets, including #&, #|, #&&, #||, #<<, #>>, #%, #mod, and #div.
  • hfadl_scale hfadl_scale provides a horizontal fader scale with its maximum at the left, intended for a 121-pixel-wide horizontal slider whose value range runs from 120 down to 0.
  • fluid.pca fluid.pca performs Principal Component Analysis (PCA) on a fluid.dataset to reduce dimensionality, such as transforming 13 MFCC values into 2.
  • mtx_prod mtx_prod computes the column-wise product of a matrix and outputs the products as a list.
  • matrix.atanh matrix.atanh computes the element-wise hyperbolic arctangent of a matrix, producing a new matrix.
  • mtx_transpose mtx_transpose transposes a matrix, exchanging its rows and columns.
  • math.reciprocal~ math.reciprocal~ calculates the reciprocal (1/x) of an input signal and outputs the resulting signal.
  • math.trunc math.trunc truncates its input to an integer value, outputting the nearest integral value that is no larger.
  • mtx_int mtx_int computes the integer value of each element in an input matrix and outputs the resulting matrix.
  • map easyflow/map converts a stream of numbers from one numeric range to another.
  • exponential_sigmoid exponential_sigmoid curves a control input using a double-exponential function, mapping its output to the range 0 to 1.
  • cd4008 cd4008 emulates a CMOS 4-bit full adder for adding two 4-bit inputs.
  • pol2car The pol2car object converts polar coordinates (amplitude and phase) into their Cartesian equivalents (real and imaginary parts).
  • mtosf jl/mtosf converts a relative semitone value into a speedup factor.
  • henon henon calculates output from the non-continuous Henon attractor.
  • fd_sin fd_sin is a wrapper for sine that outputs the sine of the input multiplied by π and a cycle factor.
  • sub~~ sub~~ performs double-precision signal subtraction, producing the difference between its two inputs.
  • mel2hz The mel2hz object converts a frequency value from the Mel scale to the linear Hertz scale.
  • radtodeg~ radtodeg~ converts a signal containing angles in radians to degrees.
  • plot.logspace~ plot.logspace~ generates a signal sequence whose values are evenly spaced on a logarithmic scale, ranging in linear space from base^start to base^stop.
  • list-minmax list-minmax finds the minimum and maximum float values in an input list.
  • rational.from_float rational.from_float converts an input float to a rational number with a specified precision.
  • math.sync_rshift math.sync_rshift performs a synchronous signed bitwise right shift and outputs the result.
  • turntodeg~ turntodeg~ converts an input signal representing turns into degrees.
  • ls.unop ls.unop applies a unary operation or expression to each element of an input list and outputs the results as a list.
  • mtx_atan mtx_atan computes the arc tangent of each element in an input matrix and outputs the resulting matrix.
  • conv.dbfs2amp conv.dbfs2amp converts decibel full-scale (dBFS) values to amplitude, accepting either a float or a list and outputting the converted value.
  • mov.rms~ The mov.rms~ object calculates a running Root Mean Square (RMS) of an audio signal over a specified time window (number of samples).
  • local_min local_min outputs the value of each local minimum in an incoming stream of floats.
  • vclip vclip clips each element of an input vector (list) between lower and upper bounds, outputting the resulting list.
  • median_5 median_5 is a control abstraction that outputs the median value of the last five float samples.
  • gemlist_info The gemlist_info object takes a gemlist as input and decomposes its current transformation matrix into basic transformations.
  • numeric.complex numeric.complex is an index of objects for creating, inspecting, converting, and performing arithmetic and transcendental operations on complex-number data.
  • cmul~ cmul~ performs complex multiplication on signals.
  • lotkavolterra lotkavolterra generates the non-continuous Lotka–Volterra attractor described as being from Cliff Pickover.
  • vector- vector- subtracts a constant offset from every number in a vector, where a vector is represented as a list.
  • float2mapping float2mapping maps floating-point values between ranges, with minimum and maximum values shown for the mapping.
  • rational.abs rational.abs computes the absolute value of rational data and outputs the result as a Rational value.
  • kalman The kalman object implements a simple, linear, one-dimensional Kalman filter.
  • acos The acos object calculates the arc-cosine (inverse cosine) of a given number.
  • shaper~ The shaper~ object performs waveshaping by mapping input signal values to a transfer function, which can be defined by an external array or an internal Chebyshev polynomial.
  • pz2coeff The pz2coeff object converts pole and zero coordinates, along with an overall gain, into biquad filter coefficients.
  • prime The prime object detects if an input number is prime.
  • vfad_scale vfad_scale provides a dB scale for a vertical slider, intended for a 121-pixel-high vsl.
  • frac.add The frac.add object is used to add two fractional values.
  • scale~ scale~ maps an input signal range to an output signal range, allowing for linear, inverted, or exponential scaling.
  • list-range list-range creates a list of numbers over a specified range, stopping just before the upper bound.
  • tdh.math.timeConversions tdh.math.timeConversions converts pulse timing among milliseconds, beats per second (BPS), and beats per minute (BPM), making it useful for translating between duration or delay values and musical tempo specifications.
  • mapping2float mapping2float converts values in the 0–1 range to a specified floating-point interval.
  • hfadr_scale hfadr_scale maps a horizontal fader position onto a nonlinear scale intended for use before fad2db.
  • minimax minimax tracks the minimum and maximum values observed over time in a stream of floats whose range is unknown, while passing the input stream through its first outlet.
  • fluid.normalize The fluid.normalize object normalizes a fluid.dataset or a single data point.