Data Structures

list.sort list.sort sorts the values of an input list in ascending order and outputs a new sorted list.
local.set local.set defines a locally scoped set variable accessed by a symbolic ID, allowing objects with the same ID to share set content within that scope.
list.split list.split divides an input list or mlist into two sub-lists: the first contains the specified number of elements, and the second contains the remainder.
flow.queue flow.queue is a multi-channel control-flow synchronization queue (FIFO) with 1–32 independent lines.
tabreceive_mult~ tabreceive_mult~ receives values from multiple arrays and outputs their sum, functioning like tabreceive~ with support for adding and removing arrays.
mtx_check mtx_check checks whether a Pd matrix message is valid and can fix an underspecified matrix by padding missing elements with zeros.
mtx_bitand mtx_bitand performs matrix logic using bitwise AND, either between two matrices or between a matrix and a scalar.
pack2 The pack2 object combines multiple inputs into a single list, similar to pack.
ossia.model ossia.model creates a namespace node that groups several ossia.param objects, helping build complex, nested address hierarchies that reflect the patcher hierarchy.
tab_downsample_min tab_downsample_min downsamples values from a source table into a destination table, retaining minimum values during the reduction.
fd_dataGui fd_dataGui is a graphical controller intended for use with fd_data, allowing you to select tables and trigger graphing with controls for curve type and type-specific parameters.
h_queue h_queue stores Pd data in a first-in, first-out (FIFO) queue, intended as a container for uses such as algorithmic composition.
prepender prepender prepends a specified value or sequence to incoming messages; when no argument is supplied, it defaults to list.
fd_array2pix fd_array2pix displays the values of a source array as grayscale pixels in a Gem list.
h_deque h_deque implements a double-ended queue for storing Pd data, with operations to access, add, or remove elements at both the front and back.
list.unique list.unique removes duplicate elements from an input list or mlist and outputs the resulting list.
fd_dataMorph fd_dataMorph morphs between two fd_data datasets by cloning an instance for each array element and creating a line for each source/target value pair.
list-in list-in checks whether an item exists in a list.
list.enumerate list.enumerate enumerates an input list or mlist by placing each element’s index after its value and outputs the resulting list.
replace The replace object modifies an input list by substituting an element at a specified index with a new value.
matrix.zeros matrix.zeros creates a matrix filled with zeros.
tab_downsample_max tab_downsample_max downsamples data from a source table into a destination table by retaining maximum values over groups of samples.
list-exec list-exec computes a specified function on every element of an input list.
list-splat list-splat is an advanced form of list split that divides an incoming list while moving the right part of the list to the left.
listPick listPick picks elements from a previously stored list.
pb_encode pb_encode accumulates field <tag> <wire_type> <value...> messages and encodes them as length-prefixed Protocol Buffers bytes suitable for comport.
list-sort list-sort sorts an incoming list of values in ascending or descending order.
mtx_diag mtx_diag creates a diagonal matrix and can also extract the diagonal of an input matrix.
listSearch listSearch searches a list for a specified element and outputs the indexes of all its occurrences.
ceammc.preset ceammc.preset is presented as an overview of preset-related objects for loading and storing float and symbol presets.
list-value-extend list-value-extend appends new input to the current list value stored under a given name.
apf apf is an AutoPreset object for float values, identified by required Ref and Name arguments and an optional BusName.
scrolllist scrolllist displays text items in a patch window as a circular list, supporting operations such as adding, inserting, replacing, deleting, sorting, seeking, reading text, and clearing the list.
stash stash is a preset-management abstraction that connects to value-control objects to save and restore their float or float-list states, typically under the control of stash/hub.
pmpd The pmpd object in Pure Data implements a mass-spring-damper physical model.
ls.choose ls.choose selects a random element from a list, outputting the element from its left outlet and its index from the right outlet.
tabReverse tabReverse reverses the contents of an array, providing an in-place way to invert its element order.
h_set h_set stores a set of elements, allowing data to be added, queried, and removed; a query outputs 1 when an element is present and 0 otherwise.
tab+ tab+ provides a short way to increment values in a Pd table.
list-drip list-drip drips or serializes an input list, sending its elements individually from the first outlet.
fd_pix2list fd_pix2list dumps an incoming Gem list as a grayscale list whose size is a power of two, cropping and truncating non-power-of-two images according to the smaller image dimension.
mtx_fill_rowcol_grid mtx_fill_rowcol_grid fills a given matrix with supplied values at the grid positions defined by row and column indices, and outputs the resulting matrix.
passNthElement passNthElement takes a list and outputs only the element at a selected index, serving a purpose similar to list-abs/list-nth and listPick.
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.
list-grow list-grow grows a list by appending each new incoming item.
left2right left2right takes a list and outputs its elements from left to right.
fd_gembuf fd_gembuf buffers incoming gemlists, using Gem's pixel-buffer facilities.
list.unzip list.unzip splits an input list across N separate outlets by deinterleaving its elements; for example, with N = 2, 1 2 3 4 becomes 1 3 and 2 4.
array.plot~ array.plot~ plots an input signal into a specified Pd array.
mtxgui mtxgui is a vanilla abstraction and GUI for working with matrices, supporting cell, row, column, and whole-matrix updates and queries with output tags suitable for routing and use with iemmatrix.
data.float data.float is a robust float storage object that can be initialized with a float value.
array-sort array-sort sorts the values of a referenced array in ascending or descending order in response to messages at its first inlet, and outputs the values’ original indices as a list from its first outlet.
deque deque is a double-ended message queue for storing messages and adding or removing them at either the front or end.
ds-color-sel ds-color-sel is a color selector for Pure Data data structures.
list-extract list-extract grabs a specified number of elements from a zero-based position in a list, providing the extracted elements and the remaining list.
insert The insert object allows you to insert elements into a message (list) at a specified index position.
list2symbol The list2symbol object converts an incoming list into a single symbol.
list-rdrip list-rdrip serializes a list in reverse order, outputting its last element first.
list-swap list-swap swaps two elements of an input list at specified indices and outputs the resulting list.
mtx_tab mtx_tab is a matrix object that uses a Pd table for local or global storage of its data.
mtx_atan2 mtx_atan2 computes the arctangent (atan2) element-wise for matrix data and outputs a matrix.
listReplaceAtIndex listReplaceAtIndex is an abstraction that substitutes an item at a specified index in a list.
list-partslow list-partslow serializes a delimited list on demand.
msgfile The msgfile object reads and writes messages to text files, extending the functionality of textfile.
pb_unwrap pb_unwrap decodes a complete Protocol Buffers sub-message from a list of byte-valued floats (0–255), emitting each decoded field from its left outlet and an ok <nfields> or error <reason> status from its right outlet.
fd_winconcat fd_winconcat performs equal-size window concatenation into a named array, serving as a simpler form of fd_wincat.
data.mlist data.mlist is a multidimensional list container for storing and manipulating lists that may contain nested lists or symbols with spaces.
slist slist maintains a named, shared list of symbols and supports adding symbols, reporting its length, retrieving the nth symbol (indexed from 1), finding a symbol’s index, printing, and resetting the list.
--value --value provides a pre-decrement operation for a named Pd value, such as $0-apple.
fd_dataStoreGui fd_dataStoreGui provides a GUI for storing data-structure arrays in text objects; see fd_data.pd for related context.
linspace linspace generates a list of linearly spaced floats between a start value and an end value.
matrix.replace matrix.replace replaces matrix elements equal to an old value with a new value and outputs a new Matrix.
list.rldecode list.rldecode decodes run-length encoded lists by repeating each element from the first input list according to the corresponding count in the second list.
mtx_index2rowcol mtx_index2rowcol converts a matrix or vector of linear matrix indices into separate matrices of row and column indices, compatible with indices used by objects such as mtx_find, mtx_index, and mtx_fill.
pofjson pofjson provides read-only JSON file utilities, loading JSON data and retrieving element sizes, strings with gets, or numbers with getf.
array-lesser array-lesser searches the currently referenced array for values smaller than a query value received at its first inlet.
llist-rdrip llist-rdrip outputs any input list as a reversed sequence of its elements.
dict.values dict.values extracts the values from a data.dict dictionary and outputs them as a data.mlist.
ls.get ls.get retrieves an element from a stored list by integer index and is the same as ls.getRotate.
mtx_fill_col_grid mtx_fill_col_grid fills supplied matrix or vector values into specified column indices of a given matrix, producing a matrix containing the inserted values.
matchbox The matchbox object stores a collection of lists and retrieves them based on various matching algorithms.
fluid.bufcompose The fluid.bufcompose object copies and combines audio data from a source buffer/array to a destination buffer/array, applying a specified gain.
shmem shmem lets Pd use a shared-memory segment to store, read, clear, and transfer floating-point data to or from arrays.
list-fifo list-fifo stores incoming lists or elements in first-in, first-out order and outputs them when triggered to “pop.” Send bang to trigger output, and use clear to reset the stored list..
mtx_index_rowcol mtx_index_rowcol retrieves values from a matrix at given row/column indices and outputs a matrix containing those indexed values.
listRemove listRemove removes the n-th element from an input list; for example, listRemove 3 targets the third element.
list-remove list-remove removes a specified number of elements from a list, beginning at a given zero-based position.
fluid.labelset The fluid.labelset object is a container that associates string identifiers with corresponding labels, primarily used in conjunction with fluid.dataset~ for machine learning tasks.
fd_triangle~ fd_triangle~ computes a triangle curve and loads it into an array, for use by fd_windows.
data.color data.color stores a data:color value and provides methods to create, inspect, and transform it using RGB, HSL, HWB, OkLab, hexadecimal, alpha, mixing, and other color operations.
matrix matrix is the ceammc matrix data type and a family of objects for creating, transforming, inspecting, and performing mathematical operations on matrices.
pdp_reg pdp_reg is a packet register that works like Pd's float or int objects: it stores a PDP packet for later output.
list-rotate list-rotate circularly rotates the elements of a stored list, outputting the reordered list.
array-append array-append appends a list received at its first inlet to the end of the currently referenced array, resizing the array as needed.
mtx_bitright mtx_bitright performs a bitwise right shift on matrix elements.
list.reverse list.reverse reverses the order of elements in an input list and outputs the reversed list.
gsave gsave provides a way to save values for multiple names under a shared global name, as illustrated by messages tagged s1 through s4.
lmap lmap provides an interface to Lua tables for storing and indexing associative key-value mappings.
pak The pak object combines multiple inputs of various types (float, int, symbol) into a single list.
list_merge list_merge composes a serial stream of atoms or sub-lists into a collected, rebuilt list.
thresh The thresh object collects incoming numbers and lists, combining them into a single output list if they arrive within a specified time interval.
sarray sarray provides a named, shared array of symbols, with an optional initial length and default symbols for empty elements.
fd_dataMorphGui fd_dataMorphGui provides a GUI for data morphing and is intended for use with fd_data.
fd_arraymorph fd_arraymorph morphs a recipient array from a source array toward a target array over a specified duration.
list-shuffle list-shuffle reorders an incoming list randomly.
mtx_abs mtx_abs computes the absolute value of each element in an input matrix and outputs the resulting matrix.
listUnfold tof/listUnfold outputs the individual elements of a list, along with their indices.
___mtx_preset__ _mtx_preset is the same as mtx_preset but adds read and write functionality.
list.resize list.resize changes the size of an input list and outputs the resized list.
pdp_snap pdp_snap takes a snapshot from a PDP stream by storing the next packet that arrives at its second inlet after receiving snap.
tab_counter tab_counter uses each element of a source array to control an increment in the corresponding counter of a destination array, then outputs a bang.
array-dbtorms array-dbtorms converts every value in the currently referenced array from dB to RMS amplitude units when it receives a bang.
unpack~ The unpack~ object converts a list of floating-point numbers into an audio signal.
h_multimap h_multimap stores key–value pairs like h_map, but allows a key to have multiple values.
local.mlist local.mlist defines a named, locally scoped mutable-list variable that can be shared by objects using the same symbol ID.
ls.shuffle The help patch does not document ls.shuffle; it documents ls.scramble, a vanilla abstraction that randomly scrambles the elements of an input list.
fd_getsize fd_getsize gets the size of an array in a data structure.
global.mlist global.mlist defines a global-scope mutable-list variable accessed by a symbolic ID, allowing instances with the same ID to share the list.
h_stack h_stack stores Pd data in a last-in, first-out (LIFO) stack, supporting operations to push data, inspect the top item, and remove the top item.
tabindex~ tabindex~ writes incoming signal values into a table at arbitrary locations, using a sample-index input to select where values are stored.
join The join object combines messages of any type from its multiple inlets into a single output list.
cxc_prepend cxc_prepend prepends specified content to arbitrary-length lists and other Pd messages, providing a way to add a prefix before output.
list-accum list-accum adds all floats in an input list and outputs the result.
iem_anything iem_anything is a latch for arbitrary Pd messages, analogous to float for float messages or symbol for symbol messages.
list-sample list-sample grabs a specified number of unique random items from an incoming list.
mtx_fill_row_grid mtx_fill_row_grid fills values into specified row indices of a given matrix and outputs the matrix containing the inserted values.
mtx_cholesky mtx_cholesky decomposes an input matrix using Cholesky's algorithm and outputs the result as a matrix.
env2array env2array renders envelope data into a specified Pd array, for example to create an array that can be played with tabplay~.
peekbag peekbag maintains a collection of numbers from value–flag pairs: a nonzero flag adds a value, while zero removes it, and duplicate values are allowed.
rational.new rational.new creates and outputs Rational data from a numerator and denominator, supplied as integer arguments or as a two-integer list.
ls.rotate ls.rotate rotates a stored list by a given integer index and outputs the rotated list.
list.separate list.separate sends the elements of an input list or mlist one at a time as separate atoms.
list.pass_if list.pass_if filters an input list or mlist, leaving only elements accepted by a predicate.
last last outputs the last element of an input list.
prevl prevl stores float inputs and outputs a list representing a vector of past input values.
array.circular~ array.circular~ provides a circular buffer backed by a named array, writing an input signal and outputting a delayed read signal.
list-split-at list-split-at splits an input list into multiple lists at occurrences of a specified atom, such as /.
list-tabdump list-tabdump outputs a table’s contents as a list, using the specified table name, count, and optional start position.
tabReverseCopy tabReverseCopy reverses the contents of one array and writes the result to another array.
apsym apsym is the AutoPreset object for symbol values.
pack The pack object combines multiple incoming atoms (numbers, symbols, or pointers) from its inlets into a single list message.
ossia ossia manages the patch’s general tree-based device, whose namespace consists of nodes declared with objects such as ossia.model and ossia.param.
list.remove list.remove removes one or more elements from an input list at specified indexes and outputs the resulting list.
fd_winreceive~ fd_winreceive~ outputs a named window table as a signal on every DSP block, for example the sinc window with argument 64.
ls.group ls.group groups incoming float, symbol, or list elements into lists of a configurable size, with the initial group size set by its float argument.
popLastN popLastN passes a list without its last N elements, providing a way to remove elements from the end of a list.
list-zip list-zip interweaves the elements of two or more lists into a single list.
pool pool is a hierarchical storage object that organizes key-associated values in directories and supports retrieval, counting, clearing, file persistence, and internal clipboard operations.
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.
list.last list.last outputs the last element of an input list or mlist.
dict.pass dict.pass filters an input dictionary, outputting a dictionary containing only the specified keys.
array-map array-map iterates over an array to modify its contents, applying a connected operation to each value, such as subtracting 0.25 or multiplying by 4.
iterator iterator provides step-by-step iteration through a list, inspired by Java’s Iterator interface, and outputs a bang when iteration is complete.
fluid.ds2text The fluid.ds2text object is a utility for converting datasets into a text format within Pure Data.
tab16read tab16read reads a number from a 16-bit table16 at a specified index, outputting the table value at that index.
array.fill array.fill fills a named array with a single value, a repeating pattern, generated waveforms, or random values using uniform or Gaussian distributions.
array.do array.do iterates over a named array and allows its samples to be modified through a side chain.
array-reverse Upon receiving a bang, array-reverse reverses the order of elements in the currently referenced array.
length The length object, part of the zexy external library, determines the number of elements in an incoming list.
nbxm nbxm is a GUI number-box matrix for displaying and editing a configurable grid of numeric values, useful for setting a numeric pattern.
make-choice-list make-choice-list generates a list of choices, with controls for minimum and maximum list length and minimum and maximum values.
ls.circgroup ls.circgroup groups incoming float elements into a fixed-size list that acts as a circular buffer, prepending each new element and discarding the oldest element from the tail once the maximum length is exceeded.
fd_trapezoid~ fd_trapezoid~ computes a trapezoid curve and is used by fd_windows.
tab16write tab16write writes numbers to a 16-bit table created with table16.
prepend The prepend object adds a specified message or argument to the beginning of any incoming message.
global.int global.int defines a named, globally scoped integer variable that can be accessed by multiple instances sharing the same symbol ID.
tab2flist tab2flist outputs values from a named table as a list of floats when banged; its argument specifies the table name.
list-idx-many list-idx-many is like list-idx, but it accepts multiple indices and retrieves the corresponding elements from an input list.
list-autorotate list-autorotate rotates the elements of an incoming list and outputs every rotation, making it useful for generating all rotations of a chord.
matrix.col matrix.col creates a Matrix column from specified values and outputs the resulting column as a Matrix.
packel The packel object extracts elements from a list, referred to as a "package." It can retrieve a specific element by its index (positive for from the beginning, negative for from the end), or the entire list if the index is 0.
mtx_row mtx_row sets rows of a matrix and outputs the resulting matrix.
sublistIterator sublistIterator iterates over an input list as sublists of predefined sizes, making it useful for stepping through grouped fields such as a person’s name and address.
set.union set.union outputs the union of two given sets.
jp.coll jp.coll stores and edits collections of arbitrary Pd messages indexed by integer or symbol addresses, providing a vanilla-Pd object similar to coll.
symbol.value symbol.value gets and sets named symbol variables, providing symbol storage similar to what value and v provide for numbers by using an array.
pofxmlp pofxmlp provides XML file utilities based on pugixml, supporting loading, querying, editing, printing, and saving XML through a named reference.
listfifo listfifo is a first-in, first-out buffer for storing lists.
array.readwrite~ array.readwrite~ reads from and writes to a named array, performing the read operation before the write operation.
l2r The help patch appears to identify l2r with left2right, although its text inconsistently says “r2l.” It provides no further evidence about the object’s behavior, purpose, or usage..
add2list add2list adds elements to a list by either prepending them (the default) or appending them, as selected by its mode argument.
fd_dataMorphArray fd_dataMorphArray is used internally by fd_dataMorph.pd, with fd_data.pd referenced for related information.
fd_listout fd_listout recursively outputs all elements of a list, emitting each element as a float or symbol.
tabminmax The tabminmax object finds the minimum and maximum values within a Pure Data table.
list-union-merge list-union-merge appends each value received in the right inlet to each value in a list, producing merged combinations such as /a /b /c with /1 /2 /3.
matrix.ones matrix.ones creates a matrix filled with ones.
flow.stack flow.stack stores incoming messages in a stack, with its first inlet pushing messages and a bang outputting and removing the top element.
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.
mtx_fill mtx_fill fills elements from one matrix into specified positions of another matrix.
list_slice list_slice divides an incoming list or anything message into a serial stream of atoms or sub-lists.
mtx_bessel mtx_bessel calculates Bessel functions for the elements of an input matrix and outputs matrix results.
prepent prepent is a shortcut for passing a message through list prepend followed by list trim.
offer The offer object stores temporary x/y integer pairs.
list.remove_if list.remove_if removes elements from an input list or mlist according to a predicate.
dict.from_list dict.from_list creates a dictionary from an input list and outputs the resulting dictionary.
fd_colorpicker fd_colorpicker opens a data-structures color picker for selecting a color.
list-add list-add subtracts two lists element by element and outputs the resulting list.
uniqsym The uniqsym object removes duplicate symbols from a list or stream, maintaining a unique set of values.
fd_mtxout fd_mtxout iterates a 3×1 matrix of floats and outputs the resulting 3×1 matrices as lists.
matrix.nrows matrix.nrows returns the number of rows in a Matrix as an integer.
linear_path The linear_path object reads out values from a specified table.
fd_dataRead fd_dataRead reads from two different data-structure arrays through two inlets and provides two outlets.
l The l object (an alias for list) is used to store and manipulate lists in Pure Data.
fluid.bufselectevery The fluid.bufselectevery object extracts specific frames and/or channels from a buffer at regular intervals.
a.rotate The a.rotate object in Pure Data appends a number to the end of an array, making it useful for tracking or visualizing the history of sound parameters over time..
ls.iter ls.iter iterates through a list and outputs each element along with its index.
iem_tabread4 iem_tabread4 reads a table using four-point interpolation.
matrix.insert_col matrix.insert_col inserts a column vector at a specified zero-based column position in a matrix and outputs the resulting new Matrix.
fd_read-resize fd_read-resize reads a text file into an array, resizing the array first.
table16 table16 stores values in a 16-bit, two-byte array to reduce storage compared with normal Pd table arrays.
listSearchIterator listSearchIterator searches a list for occurrences of a specified value and outputs -1 when none is found.
ceammc.array ceammc.array is an index help patch for the ceammc library’s array-processing objects, covering operations such as playback, filling, copying, analysis, resampling, and convolution.
cellblock cellblock stores, displays, and edits two-dimensional numeric data in a spreadsheet-like grid.
list.count list.count outputs the number of items in an input list or mlist that equal a specified pattern value.
list-idx-list list-idx-list is a wrapper for list-idx, demonstrated with a list of words supplied as creation arguments.
conv.bits2pos conv.bits2pos converts an input list of bits into a list of bit positions.
zexy_index The index object creates and manages a symbol-to-integer map, allowing you to associate unique symbols with numerical indices.
list-insert list-insert inserts a list or element into an original list before the element at position POS, producing the new list.
vectorpack vectorpack creates a new vector by appending a single value to a list of numbers.
array-edit array-edit edits array properties and populates arrays.
list.set list.set replaces an element in an input list or mlist at a specified index and outputs the resulting list.
list-decorate list-decorate calls a user-defined process on an incoming list and inserts the process result into that list.
lifo lifo is a last-in, first-out buffer for storing floats.
mtx_element mtx_element sets elements of a matrix and outputs the resulting matrix.
array-shift0 array-shift0 shifts all values in the currently referenced array forward or backward by an incoming shift value.
list.insert list.insert inserts an atom or list at a specified position in an input list, producing the resulting list or mlist.
global.set global.set defines a globally scoped set variable accessed by a symbolic ID, allowing multiple objects with the same ID to share the set.
fd_dataHann fd_dataHann applies a Hann window to an array in a data structure.
spec2_tabreceive_enable~ spec2_tabreceive_enable~ receives a spectrum from a named table while allowing table reading to be enabled or disabled.
matrix.new matrix.new creates and stores Matrix data, with optional row and column counts and initial values supplied as arguments.
fd_env fd_env generates a data-structure envelope array for use with fd_data.
butfirst butfirst outputs an input list without its first element.
tabwrite4~ The help patch identifies tabwrite4~ only as a signal/array object, but provides no description of what it does or how to use it.
j.parameter j.parameter defines a named parameter for a j.model, with configurable data types, ranges, clipping, mapping, ramps, and priority.
mtx_add mtx_add performs matrix addition, either adding two matrices or adding a scalar offset to a matrix.
fd_dataExp fd_dataExp generates an exponential graph in a data-structure array.
fd_dataRand fd_dataRand fills a data-structure array with random numbers; see fd_data for the related data structure.
ceammc.list ceammc.list is the ceammc collection of objects for list processing, including querying, transforming, generating, sorting, splitting, and aggregating lists.
tabreadb tabreadb reads values from a table, with negative indexes reading the table backwards.
array-insert array-insert inserts a list of values received by its first inlet into the referenced array at the index received by its second inlet.
histogram The histogram object counts the occurrences of incoming positive integer values, storing them as indices in an internal table.
matrix.shift_row matrix.shift_row shifts the elements in each row of a matrix by N positions and outputs a new matrix.
set.size set.size reports the number of elements in an input set.
lookup~ The lookup~ object performs waveshaping distortion by mapping input signal values (from -1 to 1) to indices of an array or table, which acts as a transfer function.
pix_buffer pix_buffer is a named storage object for images, functioning similarly to a table but without direct visual access to its contents.
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.
fd_wincat fd_wincat concatenates windows next to one another in an array specified by its first argument.
list.sort_with list.sort_with sorts an input list or mlist using a user-defined comparison side chain.
array-ceil Upon receiving a bang, array-ceil rounds every value in the currently referenced array up to the next highest integer.
mtx_find_rowcol mtx_find_rowcol calculates the row and column indices of nonzero elements in an input matrix or vector.
list.zip list.zip takes N lists through N inlets and outputs a single interleaved list, serving to combine corresponding list data.
coll The coll object stores and manages collections of messages at integer or symbol addresses.
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.
list.resample list.resample resamples an input list or mlist using a specified source-to-destination ratio and outputs the modified list.
seqbank seqbank stores sequence data in rows and columns for use with objects such as sequencer, wrapping input to the next row when necessary.
polymap polymap provides a two-dimensional, polyphony-restricted map backed by a 32×32 matrix, storing values from messages of the form note x y value.
list-pad list-pad completes an input list by padding it with additional values.
mtx_concat mtx_concat concatenates two input matrices into a new matrix, either column-wise by default or row-wise.
fd_dataID fd_dataID is intended to get an ID and accepts anything at its inlet; the help text refers users to fd_data.pd for context.
h_list h_list stores Pd data as a list designed for fast insertion and removal at any position, with front/back operations and iterator-based navigation and editing.
complex.to_list complex.to_list converts complex data to a list containing its real and imaginary parts.
mtx_fill_rowcol mtx_fill_rowcol fills values into a matrix at specified row and column indices, outputting the resulting matrix.
list-change list-change is the list equivalent of change: it outputs a list only when it is new or different.
ltabfill ltabfill is a clone of lexpr that writes the result of a function into a named table; the table name is supplied as its first argument and inlet, followed by the usual lexpr expression setup.
pofxml pofxml provides XML file utilities for loading, querying, modifying, and saving XML data, including selecting elements and attributes.
textfile reloaded/textfile replaces the textfile object for Automatonism, reading from and writing to a text define structure instead of the filesystem.
hotpack hotpack is described as working like Pd’s pack object.
mtx_find mtx_find finds the indices of nonzero elements in an input matrix and outputs them as a matrix, or an empty matrix when none exist.
jp.preset jp.preset is a data-structure-based dropdown menu for storing and recalling lists of elements from a named text configuration file.
tabread4hs~ tabread4hs~ is presented as an updated version of nusmuk-audio’s tabread4c~ with an audio-rate capability.
mtx_zeros mtx_zeros creates a matrix whose elements are all zero.
matrix.insert_row matrix.insert_row inserts a row vector at a specified zero-based row of a matrix and outputs the resulting new Matrix.
mtx_roll mtx_roll shifts the columns of an input matrix and outputs the resulting matrix.
delete delete removes one or more elements from an input message (list).
local.int local.int defines a canvas-scoped named integer variable, allowing multiple instances with the same symbol ID to access it.
buffet~ buffet~ performs a variety of irreversible, destructive transformations on the contents of a Pd array, including normalization, erasing, reversing, swapping segments, and copying a time range to another array.
list.pass list.pass filters an input float, symbol, list, or mlist, leaving only elements that match its configured passed values.
llist-drip llist-drip outputs any input as a sequence, interpreting multi-item messages and explicit lists as lists to be emitted item by item.
revalue revalue provides an interface to Pd’s native value, behaving like value while allowing its name to be changed.
preset.r preset.r interfaces with a named plist and outputs the value of a specified parameter as a float.
ls.binop ls.binop performs a binary operation element by element on two lists and outputs the results as a list.
aptab aptab represents an AutoPreset table, but the table itself is not included.
list-pak list-pak works like pack but accepts elements of any type, providing a convenient way to assemble them into a list.
data.dict data.dict is a dictionary container that stores single values or lists by symbolic keys, with support for nested dictionaries.
tabsort2 tabsort2 performs a two-dimensional sort, writing to a destination table the source indices for the first N elements of two source tables, ordered decreasingly by x (columns) and y (lines).
array.plot array.plot plots data into a named Pd array.
fd_list-last fd_list-last outputs the last element of an incoming list, making it useful for selecting the list’s final item.
make-scale make-scale generates an integer list containing a specified number of integers.
valuer valuer is like receiver, but for values: instances with the same name, such as valuer dog, provide access to the corresponding named value.
fd_dataRead3 fd_dataRead3 reads from three different data-structure arrays.
fd_itpoint fd_itpoint traverses and iterates through data-structure objects in a Pd patch, outputting pointers when it receives a symbol or bang.
mtx_col mtx_col sets columns of a matrix, either a selected column or all columns.
fd_dataLine fd_dataLine represents a line into a data-structure array and is intended for use with fd_data.
ls.removeAt ls.removeAt removes (pops) the element at a specified index from an input list, outputting both the resulting list and the removed symbol or float.
list-lastx list-lastx stores incoming floats and outputs a list of the last x values.
arrayList arrayList holds a list and supports indexed operations similar to Java’s ArrayList, including getting, setting, and removing elements, clearing the list, and outputting the entire list.
f2b f2b converts an input float to a list of four floats representing its IEEE-754 binary bytes in native endianness, suitable for transmission over a serial connection.
iem_sel_any iem_sel_any stores multiple message entries and selects one by a float index, providing a way to control a message box with multiple contents.
array-shuffle array-shuffle shuffles the contents of an array, as demonstrated with the routetable array to create random routing.
mtx_repmat mtx_repmat repeats an incoming matrix vertically and horizontally to form a larger meta-matrix.
l2s The list2symbol (or l2s) object converts an incoming list into a single symbol.
list-shellsort list-shellsort sorts an input list of floats using a Shell sort and outputs the sorted list.
matrix.ncols matrix.ncols returns the number of columns in a Matrix as an integer, making it useful for querying matrix dimensions.
list-dripv list-dripv outputs an incoming list as individual float elements, one by one from left to right.
obj.props obj.props extracts properties from an object connected to its second inlet and outputs them from the first outlet as data:dict.
fd_m-comb fd_m-comb is a utility that makes combinations from fd_matrix-comb easier to retrieve by outputting their indices.
list.shift list.shift shifts the values in an input list or mlist and outputs the modified list.
list-unique list-unique removes duplicate elements from a list, providing a uniquified list at its outlet.
list_rotate list_rotate cyclically shifts the elements of an input list by a specified number of rotation steps.
fd_vidbuf fd_vidbuf links a named frame buffer to a video feed, making it useful for working with multiple video feeds.
list.append list.append appends a stored atom or list to the end of an incoming list and outputs the concatenated list; it also works with data atoms.
repack The repack object in Pure Data is used to (re)pack various data types—floats, symbols, or pointers—into fixed-size packages.
dict.get dict.get extracts the values associated with specified keys from an input data:dict, sending each key’s value through its corresponding outlet.
dict.each dict.each maps each value in an input dictionary, producing a processed dictionary.
mtx_.cmul mtx_.cmul performs element-wise multiplication of two complex-valued matrices.
listReverse listReverse takes a list and outputs its elements in reverse order.
mtx_colon mtx_colon is a matrix colon operator that creates ascending row-vector sequences from start, stop, and increment values, similar to Octave.
tab_reverse tab_reverse copies samples from a source array to a destination array in reverse order, then outputs a bang.
list.stretch list.stretch changes the size of an input list or mlist using linear interpolation and outputs the modified list.
fd_get-element fd_get-element gets an element of an array in a Pd data structure.
dictionary dictionary is an associative array that stores values under keys.
list.do list.do iterates over an input list or mlist and modifies its contents through a side chain, producing the processed list.
list.repack list.repack repacks an input list into output lists of a specified size, making it useful for dividing list data into fixed-size groups.
listSearchAndRemove listSearchAndRemove removes every occurrence of a specified element from a list.
fd_arrayclone fd_arrayclone is a clone wrapper for array, used to create and operate on multiple array objects named from a shared base such as arrname-$1.
list-reduce list-reduce reduces a list to a single value by repeatedly applying the operation connected through its right inlet, supporting tasks such as finding a minimum, maximum, or closest element.
array-delete array-delete removes a specified number of values from the currently referenced array, resizing it as necessary.
appent appent is a shortcut for passing a list through list append and then list trim.
bank bank is an overlay object that creates a memory bank of different context states.
array-abs-val Upon receiving a bang, array-abs-val replaces every value in the currently referenced array with its absolute value.
array-shift array-shift shifts all values in the currently referenced array forward or backward by an incoming shift value, wrapping values around so no data is lost.
list-extend list-extend builds and stores a list from incoming elements or lists, outputting the stored list as items are added.
listfunnel The listfunnel object receives any list and outputs its elements sequentially, each preceded by its index.
passPair passPair takes a list and passes its nth element together with the following element, providing access to adjacent pairs.
list.apply_to list.apply_to modifies a list by passing the element at each specified zero-based index to an applied object and inserting the returned value into the list.
s2l The s2l object converts an input symbol into a list.
mtx_pack~ mtx_pack~ packs signal vectors from multiple inputs—usually 64 samples each—into a matrix containing all channels from all input signals.
ls.scramble ls.scramble is a vanilla abstraction that randomly rearranges the elements of an input list and outputs the scrambled list.
fd_dataDroplet fd_dataDroplet morphs a single element from a data array; its intended context is documented in fd_data.
stream-map stream-map works like list-map for streams, applying a transformation to stream elements.
mtx_unpack~ mtx_unpack~ unpacks an incoming matrix into signal vectors, with one signal outlet per channel.
mtx_cabs2 mtx_cabs2 computes the absolute value of a complex-valued matrix and outputs a real-valued matrix.
matrix.ones_like matrix.ones_like creates a new matrix filled with ones and having the same shape as an input matrix.
symbol.v symbol.v stores and retrieves symbol variables, serving a role similar to value/v for numbers by using an array.
getNofScalars getNofScalars outputs the number of scalars in a specified Pd data structure, serving as a way to count its scalar elements.
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.
matrix.fill matrix.fill fills every element of an input Matrix with a specified value and outputs the resulting new Matrix.
global.float global.float defines a globally scoped floating-point variable accessed by a symbolic ID, allowing multiple instances with the same ID to share its value.
addlist2table addlist2table appends an incoming list to the existing contents of a table.
msg msg is a message constructor that stores a selector and message content, then outputs the resulting message.
lolotoa lolotoa manages a Lua-backed ordered list of tables containing Pd anything messages.
getNthScalar getNthScalar retrieves the scalar at a selected index from a named data-holding subpatch, providing a pointer that can be used with set to modify that scalar.
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.
h_vector h_vector stores Pd data in an index-accessible sequence for algorithmic composition and related data handling.
fd_any2list fd_any2list takes an incoming Gem gemlist and outputs a dump.
fd_data fd_data is a set of abstractions for creating data structures, built upon Pd’s 4.data.structures/05.array.pd example.
any2list The any2list object converts any incoming message into a list, standardizing various message types into a list format for further processing.
unserialize unserialize turns a stream of floats into a list.
global.bimap global.bimap is a globally visible bidirectional map container that stores left–right key pairs and supports lookup in either direction, outputting right values for left keys and left values for right keys.
complex.unpack complex.unpack unpacks a complex number into its real and imaginary components.
sieve sieve maps integer inputs to floating-point values stored at selected indices.
l2i The l2i object converts all floating-point numbers within an incoming list to integers.
mtx_and mtx_and performs logical AND operations on matrices.
hub stash/hub manages presets for one or more stash objects using snapshots and recordings.
arraysize arraysize returns the size of an array when it receives a bang.
array.each array.each processes every element of a named array through a side chain, outputting each float and accepting its processed value back.
list-sieve list-sieve looks up whether an incoming float occurs in a stored list, providing separate outputs for found and missed values.
capture The capture object stores a sequential list of incoming floats and symbols, acting as a data buffer.
sstater sstater works with saver to save parameters when only one float needs to be stored.
array-prepend array-prepend prepends the list of values received at its first inlet to the beginning of the currently referenced array, resizing the array as necessary.
butlast butlast outputs an input list without its last element.
list.at list.at outputs one or more elements from an input list at specified index positions, making it useful for selecting items from lists or mlists.
list_accum tof/list_accum accumulates incoming atoms into a list for later output.
paq paq is a lazy pack object with “anything” inlets that collects values into an output message, paired with the corresponding lazy unpack object unpaq.
tabreadl tabreadl reads a table at a float index and outputs the linearly interpolated value.
zl The zl object is a versatile Pure Data list processor that performs various operations on incoming lists based on its selected mode.
api api is the non-interpolating counterpart to apf for AutoPreset Float values.
multiarray multiarray stores, displays, and operates on multiple graphical arrays, supporting value and size access, calculations, display settings, persistence, and mono audio-file I/O.
list-find list-find finds the position or positions of a value within a list.
h_map h_map stores Pd data as key–value pairs, mapping each key to a value for later retrieval or removal.
preset.list preset.list is a named preset entry that stores and loads list values at indexed preset slots, supporting up to 256 presets.
lifop The lifop object manages multiple Last-In-First-Out (LIFO) stacks, each assigned a floating-point priority.
preset.float preset.float is a named preset entry that stores and loads float values at indexed preset slots, with support for up to 256 presets.
list-compare list-compare compares two input lists element by element and outputs 1 when they are equal or 0 when they are not.
buffer The buffer object in Pure Data functions similarly to the array object, primarily for storing and manipulating numerical data.
list list is the short form of list append and supports building and using variable-length messages by concatenating a stored second list onto an incoming first list.
glue The glue object combines two "packages" or messages, typically by appending or prepending one to the other.
apsarray apsarray is an AutoPreset helper for a moonlib/sarray, referenced by a preset reference, name, and SArray name; the SArray itself is not included.
list-value list-value works like Pd's v/value object but stores lists or other message types, and newly instantiated objects are updated as with v.
pb_decode pb_decode decodes length-prefixed Protocol Buffers frames, such as byte lists from comport, and outputs one field <tag> <wire_type> <value> message per field plus an ok <nfields> or error <reason> status.
data.set data.set is a container that stores unique elements and outputs its contents as a set.
set.contains set.contains checks whether a specified atom is present in an input set, outputting 1 when it exists and 0 otherwise.
take-two take-two takes a list as input and outputs all combinations from that list, which can be viewed with print.
mtx_scroll mtx_scroll shifts the rows of an input matrix and outputs the resulting matrix.
fd_bufvid fd_bufvid reads a Gem list from a fd_vidbuf pixel buffer and loops through a specified number of frames, enabling the same buffer to be used multiple times.
local.dict local.dict defines a dictionary variable in local scope, accessed by a symbolic ID so that local.dict objects with the same ID can refer to it.
array-copy array-copy copies data from a source array, specified through its first inlet, into the currently referenced destination array.
sradio sradio is a hacked hradio that behaves like a small array of values and provides internal preset storage and recall.
any any stores any kind of data, serving a purpose similar to Pd's f object but for arbitrary data.
list-delim list-delim splits a list according to a specified symbol.
array.set array.set sets the contents of a named array from an input list, resizing the array to match the list.
args The args object in Pure Data allows abstractions to load and dynamically manage their creation arguments.
preset.symbol preset.symbol is a named preset entry that stores and loads symbol values at indices, supporting up to 256 presets.
set.symdiff set.symdiff outputs the symmetric difference of two sets: the elements belonging to either set but not both.
fd_arraycopy fd_arraycopy copies the contents of one array to another.
array.circular array.circular reads and writes a named Pd array as a circular buffer.
rtree.to_list rtree.to_list converts an OpenMusic-like rhythm tree, used to define complex rhythmic patterns such as triplets and swing, into a list of fractions.
fd_arrayautotrim fd_arrayautotrim appears intended to automatically trim an array, as demonstrated with the word and word-trimmed arrays.
array-drip Upon receiving a bang, array-drip outputs every value from the currently referenced array, one at a time, as quickly as possible.
list-drip2 list-drip2 outputs the elements of two lists in sync, continuing for the length of the first list.
matrix.swap_cols matrix.swap_cols swaps two specified columns in a matrix and outputs the resulting new Matrix.
rational.unpack rational.unpack unpacks a rational number into its numerator and denominator, outputting each part as a float.
first first outputs the first element of an input list.
matrix.shift_col matrix.shift_col shifts the elements in each matrix column by N positions and outputs a new Matrix.
ls.splice ls.splice substitutes element N of an original list with another list, producing the resulting list.
data.list data.list is a list container for storing, retrieving, and manipulating a list through operations such as append, insert, remove, reverse, shuffle, and sort.
list-abs list-abs applies the absolute-value operation to the float elements of an input list and outputs the resulting list.
iterate The iterate object splits an incoming message into its individual elements (floats or symbols) and outputs them sequentially.
listfind The listfind object searches for occurrences of a sublist within a larger list.
listSplitOnChar listSplitOnChar splits a list wherever a given symbol occurs and outputs the resulting parts.
list.rlencode list.rlencode applies run-length encoding to an input list.
iem_pbank_csv iem_pbank_csv is a parameter bank that stores parameter sets in numbered memory lines and reads or writes them using CSV-like syntax.
set.equal set.equal checks whether two sets contain the same elements, outputting 1 when they are equal and 0 otherwise.
bytestruct bytestruct converts between Pd atoms and byte lists according to a fixed-size struct format specification, or calculates the number of bytes that format requires.
array-scramble array-scramble randomizes the order of values in the currently referenced array when it receives a bang.
stater stater works with saver to save parameters.
bitmap bitmap provides a two-dimensional array of bits represented as toggles.
ls.butlast ls.butlast returns a list without its last element.
local.float local.float defines a canvas-scoped named floating-point variable, allowing instances with the same ID to access its value by name.
presets The presets object in Pure Data manages and stores the state of other objects, particularly those connected to receive or receiver objects.
mtx_preset mtx_preset stores preset values in a matrix and retrieves rows, elements, or the whole matrix, including interpolated values between rows.
data.int data.int is a robust object for storing and outputting an integer, with an optional initial value.
plist plist saves and recalls user-defined presets, outputting a selected preset as a series of parameter lists for use with objects such as preset.r and preset.s.
list-dripdex list-dripdex behaves like list-drip, while providing the index of each item from its second outlet.
contour contour is an advanced interface for drawing precise functions into arrays by moving, creating, or deleting points on a canvas.
list.reject list.reject removes specified values from an input list and outputs the list without those elements.
last_n last_n stores the last n incoming data values in a list.
var The var object in Pure Data functions as a multi-variable storage and recall mechanism, similar to value but capable of handling multiple named variables, often as lists.
mtx_index mtx_index addresses matrix elements by their indices, allowing multiple known elements to be selected simultaneously; its output matrix has the same shape as the indexing matrix.
list2bytes list2bytes serializes a Pd list into a list of byte values, for example so it can later be reconstructed with bytes2any.
tabwrite~~ tabwrite~~ writes a double-precision signal into an array, with a creation argument that initializes the destination array name.
listReplace listReplace replaces every occurrence of a specified element in a list.
serialize serialize turns a stream of floats into a list, providing control-rate conversion from individual values to grouped list output.
listUniques listUniques removes duplicate elements from a list, leaving only unique elements.
tab16send~ tab16send~ continuously writes one block of a signal to an array, whose name is given as its creation argument.
list-slice list-slice extracts a slice from the interior of a list, using two arguments to define the slice boundaries.
dict.reject dict.reject filters an input data dictionary by removing the specified keys and outputs a new dictionary containing the remaining entries.
pv The pv object functions as a private variable, storing and retrieving any message type by name within a patch and its subpatches.
list-group list-group groups incoming list items into output lists of a specified, uniform size, serving as a clone of zl group.
list-apply list-apply applies the operation of an object created from its arguments to a list, producing a list at its outlet.
local.list local.list defines a list variable in local scope, identified by a symbol ID so multiple local.list objects with that ID can access it.
fd_windows fd_windows is a utility abstraction that loads and plots many useful window tables for selection by index with fd_seltab.
fd_scales fd_scales stores and recalls indexed scales or patterns, with four predefined choices: major, minor, augmented, and diminished.
list-count list-count counts how many times a specified argument or value from its second inlet occurs in a list.
tabCopy tabCopy copies one array into another and resizes the destination array.
array-clip Upon receiving a bang, array-clip limits every value in the referenced array to the lower and upper bounds specified at creation.
h_multiset h_multiset stores Pd data as a multiset, allowing the same element to be added more than once and reporting how often queried data is present.
listto listto separates a list into a stream of individual atoms and outputs a bang when it reaches the end of the list.
list-dripslow list-dripslow serializes a stored list on demand, outputting its elements one at a time.
ui.preset ui.preset manages saved values for UI objects on the canvas that have an @presetname, allowing their settings to be stored, loaded, cleared, interpolated, and read from or written to a file.
list.^search list.^search searches stored list contents for an input atom or list and outputs its index, or -1 when no match is found.
c.pak c.pak combines several atoms into a single message and is the Cream counterpart of Pd’s vanilla pack.
list_replace_atoms list_replace_atoms replaces atoms in an incoming list with a replacement list, beginning at a specified starting index.
ls.quicksort ls.quicksort is a vanilla abstraction that sorts the elements of a list in ascending order, supporting floats and symbols, with symbols placed to the left of floats.
mtx_bitleft mtx_bitleft performs a bitwise left shift on a matrix.
list_rev_slice list_rev_slice divides an incoming list or anything message into a reverse-ordered stream of atoms or sublists.
tab_get_size tab_get_size reports the size of an array when it receives a bang.
matrix.row_at matrix.row_at extracts a specified row from matrix data and outputs it as a Matrix.
list2lists The list2lists object splits an incoming list into multiple sublists.
param param is a state-saving and message-routing system that defines named parameters for storing, restoring, routing, and optionally displaying values.
envelope envelope stores and edits a sound-envelope data value made of timed points, with segment types such as step, linear, exponential, sigmoid, and quadratic sine.
flow.sync_pack flow.sync_pack packs values from multiple hot inlets, outputting the current packed list whenever an inlet changes or receives a bang.
matrix.from_list matrix.from_list creates a new Matrix from a list of element values.
modelfiler The modelfiler object loads 3D model data from Alias/Wavefront OBJ files into Pure Data tables.
matrix.zeros_like matrix.zeros_like creates a new matrix filled with zeros and having the same shape as an input matrix.
ls.getRotate ls.getRotate outputs an element from a stored list by integer index, wrapping through the list when the index is negative or exceeds the list length.
sublist sublist extracts a sublist between specified start and end indexes.
last_n_matrix last_n_matrix saves the last n incoming data items in a column matrix, providing a rolling history of recent values.
list.length list.length outputs the number of atoms in an input list.
flow.pack flow.pack combines values from a configurable number of inlets into a packed list, or a message when given message input.
stream The stream object collects incoming numbers into an internal list.
matrix.matrix matrix.matrix serves as an index for the ceammc matrix library, listing objects for creating, transforming, analyzing, loading, and saving Matrix data.
list-iter list-iter groups incoming lists into sublists according to a size limit, serving as a clone of zl iter.
matrix.reshape matrix.reshape changes a matrix's dimensions while keeping its elements, outputting a new Matrix.
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.
list_remove_atoms list_remove_atoms removes a specified number of atoms from a list.
store The store object is an abstraction built upon Pure Data's text object, designed to sequentially store and manage incoming messages.
j.cue j.cue creates named cues that store the state of modified parameters in a j.model, and can recall or update those saved parameter values.
tabreader tabreader is a Pure Data object that reads values from an array (table) using various interpolation methods, including spline, cosine, linear, and Hermite.
bytes2any bytes2any converts lists of byte-valued floats into Pd messages, sending parsed messages from its left outlet and a bang from its right outlet after the entire input list is processed.
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.
list.repeat list.repeat outputs a new list by repeating an input list, float, symbol, or data value a specified number of times.
mtx_index_col_grid mtx_index_col_grid finds values at specified column-grid indices in a given matrix and outputs a matrix containing the indexed columns.
stack The stack object stores and retrieves messages using either a First-In, First-Out (FIFO) or Last-In, First-Out (LIFO) order, functioning as a queue or a traditional stack data structure.
fd_logistic~ fd_logistic~ is the same as fd_logistic, but stores its output into an array using DSP, and is used by fd_windows.
sort The sort object sorts incoming messages, typically lists of numbers, in either ascending or descending order.
copyList copyList takes an incoming list and copies it to message boxes.
list-part list-part splits an incoming list into a head and a tail.
list.walk list.walk iterates through a list, outputting the current element and moving forward or backward in response to bangs, floats, or next/prev messages.
list_get_atoms list_get_atoms extracts a specified number of atoms from a list, beginning at a specified index.
list-sect list-sect outputs the elements common to both input lists, providing the intersection of two lists.
symbol2any The symbol2any object converts an incoming symbol into an "any" message.
c.matrix c.matrix creates a resizable matrix that can serve as a breakpoint function and stores values in cells addressed by column and row.
array-greater array-greater searches the currently referenced array for values that exceed a query value received at its first inlet.
list-toggle-pairs list-toggle-pairs turns a stream of item/toggle pairs into a list of currently active unique items, making it useful for tracking which keys are being held.
tabsave tabsave outputs the contents and size of a named array as a message, allowing the array data to be stored in a message box.
++value ++value provides a pre-increment operator for a named Pd value.
list.^at list.^at stores a list and outputs the element or elements at positions supplied as an integer index or a list of indexes.
list-map2 list-map2 applies a user-defined operation to each pair of corresponding elements from two lists, producing a list of results.
list-delete list-delete removes one or more items from a list, starting at the zero-based position POS.
tab_copy tab_copy copies sample values from a source array to a destination array when it receives a bang, then outputs a bang.
ls.nearest ls.nearest iteratively searches a list for the number nearest to a target value.
matrix.size matrix.size reports the dimensions of matrix data as a list containing the number of rows and columns.
list-lifo list-lifo stores incoming lists or elements by “pushing” them and outputs stored data when “popped.” Send a bang to trigger output, or send clear to reset the stored list..
tolist tolist builds a list from a stream of incoming data.
colors The colors object in Pure Data functions as a color picker and converter, allowing users to select colors via a GUI and convert between various color formats like RGB, Hex, CMYK, HSL, and HSV.
list2matcol list2matcol converts an input list into a column matrix.
matrix.row matrix.row creates a Matrix row from specified values and outputs the resulting row as a Matrix.
fd_getid fd_getid gets the ID of an array in a data structure.
mtx_reverse mtx_reverse reverses the order of a matrix’s columns, rows, or individual elements.
fluid.bufinfo The fluid.bufinfo object is a utility for inspecting fluid.multiarray objects and other arrays/buffers.
array-rand-fill Upon receiving a bang, array-rand-fill fills the currently referenced array with random numbers between the inclusive bounds given as creation arguments.
array-unique Upon receiving a bang, array-unique searches the currently referenced array for unique values.
py.utils py.utils provides utility objects for converting Pd atoms to Python objects and working with Python lists, including selection, append, reverse, length, remove, and split operations.
patch.tree patch.tree outputs the current patch tree as a Dict.
global.list global.list defines a globally scoped list variable accessed by a symbolic ID, allowing multiple instances with the same ID to share the list.
matrix.swap_rows matrix.swap_rows swaps two specified rows of a matrix and outputs the resulting new Matrix.
data.bimap data.bimap stores pairs in a bidirectional map, allowing a left key to retrieve its right value and a right key to retrieve its left value through separate inlets and outlets.
fd_array-rerange fd_array-rerange remaps the elements of a named array to a new range.
fd_getcomb fd_getcomb computes the complement between two lists, outputting the elements in the first list that differ from the second.
array.copy array.copy copies samples from a source array to a destination array, either as the whole array or from a specified source position or range, optionally starting at a specified destination position.
list-seek list-seek walks through a stored list element by element, similarly to textfile.
array-copy-range array-copy-range copies a specified range of points from a source array into the currently referenced destination array.
fluid.knnclassifier The fluid.knnclassifier object implements a K-Nearest Neighbors classifier, leveraging a fluid.kdtree for efficient data searching.
matrix.vectorise matrix.vectorise converts matrix data into either a column vector or a row vector, output as a Matrix.
list-filter list-filter returns a list containing only the input items for which a connected operation produces a true value; any value other than 0 is considered true.
h_priority_queue h_priority_queue stores Pd data in a priority queue, with messages to push values, inspect the top item, remove it, test for emptiness, and report its size.
list.first list.first returns the first element of an input list.
ceammc.global ceammc.global refers to ceammc’s family of global named data objects: global.dict, global.float, global.int, global.list, global.mlist, and global.set.
listIntersection listIntersection calculates the intersection of two Pd lists, whose elements are floats or symbols.
rational.to_list rational.to_list converts Rational data into a list containing its numerator and denominator parts.
symbol2list The symbol2list object converts an incoming symbol into a list.
fd_2bit fd_2bit converts an incoming float into a binary list through one outlet.
mtx_cinverse mtx_cinverse computes the inverse of a complex-valued matrix.
dict.size dict.size reports the size of a dictionary.
list_unfold tof/list_unfold outputs the individual elements of a list, with the element index available from its second outlet.
pbank pbank is a two-dimensional parameter bank that stores floats or symbols in configurable columns and rows, supporting preset storage, recall, interpolation, and file I/O.
funbuff The funbuff object stores and manages ordered pairs of x/y integers, functioning as a lookup table or a simple function buffer.
c.preset c.preset saves and recalls presets for compatible Cream external objects that share a preset name; current presets are saved with the patch.
list-clip list-clip clips lists, serving as the list-oriented counterpart to clip.
stream-fromtext stream-fromtext reads the contents of a named text object and outputs them as a stream of lines.
set.diff set.diff computes the difference between two sets, outputting the elements of the first set that are not in the second.
tab_const tab_const sets samples in a destination array to a constant value: a float fills all samples with that value, while a bang sets them all to zero.
msg.pack msg.pack packs atoms received through 1–32 inputs into a single message, optionally preceded by a configurable message prefix.
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.
peek~ The peek~ object provides functionality to read and write individual values to and from arrays in Pure Data.
ltabdump ltabdump outputs the contents of a Pd table as a list, as demonstrated by sending its output to print.
preset.s preset.s interfaces with plist by sending a float value back to a named parameter and updating it.
dict.keys dict.keys gets the list of keys from a data.dict dictionary.
fd_dataWalk fd_dataWalk performs a random walk into a data-structure array and is intended for use with fd_data.
j.parameter_array j.parameter_array defines a numbered collection of Jamoma parameters from an indexed address such as track.[4]/gain, with attributes such as @type and @description.
list_sort2 list_sort2 sorts a list and outputs the sorted list and its sorting indices, while applying the same ordering to a second list.
stream-totext stream-totext writes an incoming message stream into a named text define object, here stream-totext-help.
fd_matrix-comb fd_matrix-comb is a simplified abstraction of the choice object for selecting an indexed tuple from a list.
list-const list-const creates a list by repeating the same item a specified number of times.
list-enumerate list-enumerate serializes an input list and prefixes each element with a number, as illustrated by the list a b c d 0 1 2 3.
list-len list-len calculates the length of a list and outputs the result as a float.
sql_query sql_query represents an SQL query and supports query text containing ? placeholders, as shown by the INSERT example.
flow.group flow.group accumulates incoming floats, symbols, list atoms, and data into a list of a specified size, outputting and clearing the group when it is full.
rotate The rotate object reorders elements within incoming messages or lists.
fd_smooth_brute fd_smooth_brute snaps extreme values in a named array to zero.
receive2list receive2list converts messages received from configured receive symbols into a list, prepending a float that corresponds to each symbol.
remove The remove object filters a list by excluding specified numeric elements.
tabfind tabfind searches the named array for an input float or sequence of floats and outputs its index, or the array length if no match is found.
tab16receive~ tab16receive~ continuously reads blocks of a 16-bit signal from an array.
ls.last ls.last gets the last element of an input list.
list-nth list-nth outputs the element at a specified zero-based position in an input list.
tabsort tabsort writes to a destination table the indices of elements in a source table, ordered by sorting the first n source elements.
list-map list-map applies a user-defined operation element by element to an incoming list and outputs the resulting list.
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.
tabload tabload an_array2 loads data into the named Pd array, serving as the counterpart to tabsave.
tabread2 tabread2 reads numbers from a named array using 2-point interpolation at a fractional index.
fd_shuffle fd_shuffle pseudorandomly shuffles the contents of a named array and has no outlets.
complex.new complex.new creates Complex data from real and imaginary float components and outputs the resulting Complex value.
lace The lace object interleaves two or more incoming lists into a single output list.
tab_downsample tab_downsample downsamples data from a source table into a destination table, using a specified downsampling factor.
fifop The fifop object implements a First-In-First-Out (FIFO) queue system that manages multiple internal queues, each capable of being assigned a floating-point priority.
apmaster apmaster Ref saves and loads all presets belonging to Ref and its children to or from a single text file.
array-between array-between searches the currently referenced array for values strictly between the two boundaries received as a two-element list at its first inlet.
data.fifo data.fifo is a First-In-First-Out queue container that stores data and outputs values in insertion order.
fd_dataVis fd_dataVis provides a GUI for raising the data-structure arrays in fd_env, intended for data visualization.
niagara The niagara object divides an incoming message or list into two sub-packages.
flow.ring flow.ring is a dataflow ring buffer with a configurable length from 1 to 24.
list-idx list-idx outputs the element at a specified position in a list.
mtx_.cdiv mtx_.cdiv performs element-wise division of two complex-valued matrices.
tab- tab- provides a short way to decrement values in a Pd table.
tabsize tabsize reads or changes the size of a named table.
unpack The unpack object splits an incoming message or list into its individual atoms, sending each atom to a separate outlet.
mlist.flatten mlist.flatten flattens a nested mlist into a single, non-nested mlist.
mtx_index_row_grid mtx_index_row_grid finds values at specified row-grid indices in a given matrix and outputs a matrix containing the indexed rows.
matrix.col_at matrix.col_at extracts a specified column from matrix data and outputs it as a Matrix.
mtx_resize mtx_resize resizes an incoming matrix to a specified number of rows and columns, then outputs the resized matrix.
matrix.full matrix.full creates a matrix with the specified number of rows and columns, filling every element with a given value.
list.rotate list.rotate rotates an input list to the left and outputs the rotated list.
fd_arraysort1 fd_arraysort1 is intended to sort the array named by its first argument in ascending order by default or in descending order.
set.intersect set.intersect outputs the intersection of two sets.
fluid.datasetquery The fluid.datasetquery object allows users to query and filter FluidDataSet objects.
msg_pbank msg_pbank provides scene-based storage for message data, with the creation argument apparently setting the bank size (for example, msg_pbank 20).
weightmap weightmap stores a vector of weights or probabilities and maps an incoming float to the integer index of the matching stored weight.
list-rot list-rot rotates the elements of a list by moving a specified number of elements from the front to the back.
fluid.grid The fluid.grid object maps a set of 2D points from a fluid.dataset into a rectangular grid.
ui.matrix ui.matrix is a rectangular UI matrix of toggles for displaying and managing a grid of binary cell states.
combine The combine object collects incoming messages into a single list if they arrive within a specified time interval.
getAllScalars getAllScalars reads a data-holding subpatch and outputs a pointer to each scalar it contains.
json json-encode builds an internally stored JSON object or array and outputs it as a JSON string, while json-decode converts a JSON string into lists of key/value pairs.
gemlist The gemlist object stores a list of GEM graphics commands or data.
index~ The index~ object reads values from an array without interpolation, similar to tabread~ but with rounded index values.
fifo fifo is a first-in, first-out buffer for storing floats.
ceammc.local ceammc.local groups canvas-scoped named variables and local named container objects in the ceammc library.
mtx_index_rowcol_grid mtx_index_rowcol_grid retrieves values at a grid of row and column indices from a given matrix.
midi-noteson midi-noteson receives incoming MIDI data from a notein object and outputs lists containing all currently sounding note-on notes.
array.resample array.resample resamples a source array into a destination array using a configurable source-to-destination ratio and quality setting.
lister The lister object (alias l) stores and outputs lists, and can also append one list to another.
dict.to_list dict.to_list converts an input data dictionary into a plain list.
list.each list.each maps each value of an input list or mlist through an external side chain and outputs the resulting modified list.
list-popfirst list-popfirst stores a list of numbers and pops its first element, outputting that float and removing it from the stored list.
preset-manager preset-manager stores all parameter values in a patch in 16 slots, allowing states to be recalled manually, selected by CV, or stepped through sequentially by a trigger/gate.
flist2tab flist2tab loads a float or list of floats into a table, starting at the offset supplied to its second inlet; its argument specifies the table name, which can also be changed with a set message.
state The help patch identifies state as a control object related to state saving, with an inlet labeled save and one outlet.
rec The rec object in Pure Data records and plays back any messages across multiple independent tracks (up to 64).
fluid.dataset The fluid.dataset object acts as a versatile container for associating data points with unique identifiers, crucial for FluCoMa data analysis.
mtx_cart2sph mtx_cart2sph converts a matrix of Cartesian vectors into spherical coordinates.
tab_downsample_average tab_downsample_average downsamples values from a source table into a destination table by averaging groups according to a factor.
list_rev_merge list_rev_merge composes a serial stream of atoms or sub-lists into one list, rebuilding the collected elements in reverse order.
matrix.at matrix.at selects a matrix element at a specified zero-based row and column and outputs it as a float.
fluid.ls2text fluid.ls2text is a utility object designed to convert a fluid.labelset from a fluid.dataset into a text object.
matrix.remove_row matrix.remove_row removes a specified row from a matrix and outputs the resulting new Matrix.
fd_arraysort2 fd_arraysort2 sorts a named array in ascending or descending order and provides the sorted array values as a list.
local.bimap local.bimap is a patch-local bidirectional map container that stores left–right pairs and supports lookup in either direction.
array-nearest array-nearest searches its currently referenced array for the value nearest to a query value received at its first inlet.
list-dripx list-dripx outputs a specified number of elements from a list at a time.
right2left right2left takes a list and outputs its elements, apparently iterating from right to left as indicated by its name and the related left2right object.
tabset The tabset object from the zexy library allows users to set the contents of a Pure Data table.
data.set2list data.set2list converts an input set into an output list.
mtx_cos mtx_cos computes the cosine of each element in an input matrix and outputs the resulting matrix.
list-replace list-replace replaces part of a list starting at a specified position, using another list as the replacement.
data.copy data.copy creates a copy of input data of any supported data type, such as MList or Set.
matrix.diag matrix.diag extracts a specified diagonal from a matrix and outputs it as a column matrix.
fluid.multiarray The fluid.multiarray object creates and manages multi-channel arrays, allowing users to store and retrieve lists of values across multiple independent channels.
list-equalize list-equalize scales a list by dividing its float elements by their sum, so those elements sum to 1.
listCollect listCollect is an abstraction for reconstructing a list from elements produced while processing an original list.
list_reverse list_reverse reverses the order of atoms in an input list and outputs the reversed list.
arraycopy arraycopy copies data from a source array to a destination array, either copying the whole array or a selected range.
flow.mem flow.mem stores data flow in 1–32 memory cells, with each of its first N inlets writing to the corresponding cell.
mtx_size mtx_size reports the size of an input matrix.
table The table object stores and edits a number array, which can be graphically manipulated via an editor window or by double-clicking.
list-rev list-rev reverses the order of elements in a list and outputs the reversed list.
saver saver globname provides save and load control for state associated with the shared name globname, as demonstrated with stater and sstater objects.
array-equals array-equals searches the currently referenced array for occurrences of a query value received at its first inlet.
list.map list.map maps list values through a specified dictionary whose entries use the form [KEY: VALUES...].
spec2_tabreceive~ spec2_tabreceive~ receives a spectrum from a table named by its symbol argument.
list-fifo-delim list-fifo-delim stores incoming list messages or elements and outputs the stored list when triggered, using a delimiter symbol between messages; the delimiter defaults to the empty symbol and can be changed manually.
multi.vsl The multi.vsl object provides a graphical multi-slider interface for Pure Data, allowing users to control and visualize multiple numerical values.
mtx_cmul mtx_cmul performs multiplication of two complex-valued matrices, with each matrix supplied as separate real and imaginary parts.
tabdump The tabdump object outputs the entire contents of a Pure Data table as a list.
last-x last-x collects incoming floats into a list of the last x values and outputs that list.
list.prepend list.prepend prepends stored atoms or a list to an incoming atom, list, mlist, or other data and outputs the concatenated list.
VASP VASP is the main object of a modular vector-assembling signal-processing system that performs out-of-time calculations on Pd arrays using specialized vasp messages.
ceammc.data ceammc.data is the ceammc data library, providing objects for data types and containers such as colors, dictionaries, lists, sets, queues, and bidirectional maps.
tabwrite_dir~ tabwrite_dir~ works like Pd’s native tabwrite~ but can also write samples backward into an array.
matrix.resize matrix.resize changes a matrix’s number of rows and columns while keeping its elements and preserving their layout.
mtx_transpose mtx_transpose transposes a matrix, exchanging its rows and columns.
tabwrite__ tabwrite__ writes a number to a lookup table with double precision.
searchIncomingLists searchIncomingLists searches an incoming list for a specified element and outputs the indexes of all its occurrences.
list.reduce list.reduce cumulatively applies a binary function to the elements of an input list or mlist, producing one reduced value.
list_sort list_sort sorts a list in ascending or descending order and outputs both the sorted list and its sorting indices.
iem_tabread2 iem_tabread2 reads a table at a supplied index using two-point interpolation.
list.seq The list.seq object sequences through elements of a provided list, outputting one element at a time upon receiving a bang.
pack~ The pack~ object converts incoming audio signals into lists of floating-point numbers.
list.search list.search searches an input list or mlist for specified items and outputs each item's position, or -1 when it is not found.
global.dict global.dict defines a globally scoped dictionary identified by a symbol ID, allowing objects with the same ID to access the named dictionary.
tabdump2 tabdump2 outputs the contents of a table as a list, with optional minimum and maximum dump limits.
mtx_atan mtx_atan computes the arc tangent of each element in an input matrix and outputs the resulting matrix.
fluid.kdtree The fluid.kdtree object implements a K-dimensional tree for efficient nearest-neighbor searches within multi-dimensional datasets.
deleteScalar deleteScalar deletes a scalar from a Pd data-holding subpatch, providing a way to remove stored scalar data.
matrix.to_list matrix.to_list converts Matrix data to a list of its elements.
dict.contains dict.contains checks whether a data.dict contains specified keys.
list-reorder list-reorder rearranges the elements of a list according to a supplied list of indexes, producing the list in the requested order.
mtx_slice mtx_slice extracts a specified section from an input matrix and can be used to partition matrices.
batch.write~ batch.write~ is a convenient abstraction built upon tabwriter~ designed for recording audio signals into Pure Data arrays.
fd_dataRead1 fd_dataRead1 reads from a single data-structure array, with its argument specifying the index to read.
mtx_bitor mtx_bitor performs matrix logic using bitwise OR, either between two matrices or between a matrix and a scalar.
fd_dataMorphWidth fd_dataMorphWidth is intended for use with other fd_data* objects, but the help patch does not provide enough information to explain its specific purpose or behavior.
preset.storage preset.storage controls shared preset storage for preset-aware objects such as preset.float, preset.symbol, and preset.list, supporting storing, loading, clearing, duplicating, updating, and interpolating presets, as well as file read/write operations.
fd_list-pointer fd_list-pointer maintains an ordered list of pointers for a specified canvas.
list-extendq list-extendq builds and stores a list from incoming elements or lists.
fsdict fsdict is a dictionary-like object that stores a unique relationship between a float and a symbol, allowing either value to retrieve its associated counterpart.
tab2list tab2list retrieves a selected range of values from a table and outputs the table content as a list.
apsubmaster apsubmaster creates a sub-reference for an AutoPreset setup.
pix_buffer_write The pix_buffer_write object writes incoming image data (a gemlist) into a specified pix_buffer at a given index.
poke~ poke~ writes audio signals or control messages into a specified array at a given index, which can also be controlled by a signal.
list.slice list.slice extracts a sublist from an input list using configurable start (@from), end (@to), and step (@step) values.
matrix.remove_col matrix.remove_col removes a specified column from a matrix and outputs the resulting new Matrix.