Stochastic / Probabilistic

midi.vrand midi.vrand randomizes the velocity in a NOTE VELOCITY [DUR] list and outputs the list with its note and optional duration preserved.
many_bang many_bang generates a burst of bangs, with either a fixed count or a randomly varying count within a specified range.
rndmrange rndmrange generates a random value when triggered, with an inlet or argument setting the number of possible values.
bilex bilex generates bilinearly exponentially distributed random numbers for control use.
random__ random__ generates double-precision random numbers, described by the help patch as accurate to 14 digits.
metro.choice metro.choice is a metronome that outputs bangs at intervals chosen uniformly at random from a positive timeset in milliseconds.
tdh.math.random2choices.ui tdh.math.random2choices.ui randomly outputs one of two values, providing a UI for choosing the weighting scheme.
between-lin between-lin outputs a random number when it receives a bang—or any input—in its left inlet.
bashfest~ bashfest~ is a click-triggered sound-file player that applies randomly selected DSP processors, including filters, modulation, delay, reverb, distortion, reversal, and flam effects.
random-time-manager random-time-manager generates triggers using a random timing value bounded by the OFFSET minimum and TIME maximum controls.
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.
randn randn outputs random numbers with a Gaussian distribution when it receives a bang.
fd_markov5 fd_markov5 implements a fifth-order Markov chain with five states, providing one outlet for each state.
markov~ markov~ implements a first-order Markov chain for generating melodically coherent note sequences from a configured set of values and per-event transition odds.
fd_markov fd_markov implements a three-state Markov chain, using six probability values supplied as creation arguments or as a list to its second inlet.
rind rind is a high-precision random number generator that outputs a number within specified boundaries.
random random outputs pseudorandom integers from 0 to N−1 when banged, where N is its creation argument and can also be reset through its inlet.
random.discrete random.discrete generates weighted random integers on the interval [0, N), using a list of non-negative weights that can be supplied as arguments or set with a list.
random.gauss random.gauss generates random values with a Gaussian distribution, using a configurable mean (mu, default 0) and standard deviation (sigma, default 1).
param-nudge param-nudge is an experimental tool for exploring musical spaces by nudging parameters throughout a patch to find new sounds.
fd_wielevy2 fd_wielevy2 implements Xenakis’ Method 4, a Wiener–Lévy process with two reflecting barriers, as described on page 247 of Formalized Music.
tdh.math.random2choices tdh.math.random2choices randomly outputs one of two values, providing a simple way to make a two-option random selection.
about about generates a number randomly deviated above or below a specified center value by a percentage range.
chameleon~ chameleon~ is described as an oracular sound processor that randomly processes sound, though the help-patch text does not fully explain its processing behavior.
list-shuffle list-shuffle reorders an incoming list randomly.
linear linear generates linearly distributed random numbers for control use.
arbran maxlib/arbran generates random floating-point values conforming to a piecewise probability density defined by two arrays: a value array and a probability array.
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.
list-sample list-sample grabs a specified number of unique random items from an incoming list.
cauchy cauchy generates Cauchy-distributed random numbers for control use, outputting a float each time it receives a bang.
filtered_random filtered_random generates a stream of numbers based on randomness, with controls related to curve, timing, amplitude, and offset.
fd_rbd fd_rbd creates a random bar distribution for a requested number of bars, assigning random time signatures.
random.float random.float generates uniformly distributed random floating-point values within a specified minimum and maximum range, outputting a new value when it receives a bang.
ceammc.random ceammc.random is a library overview for ceammc random-generation objects, covering uniform integer and float generators, Gaussian and linear distributions, weighted atom and integer selection, and piecewise constant or linear distributions.
fd_s-prob fd_s-prob selects between two states according to their probabilities and is intended for use in Markov chains.
random-mixer random-mixer is a four-input mixer with per-channel gain and on/off controls, stereo left/right outputs, and individual outputs for channels 1–4.
pitch-from-intervals pitch-from-intervals generates pitch classes—notes without register—from a selectable interval list, using randomly supplied intervals.
urne urne is a unique random-number generator that outputs values without repetition until its urn is empty.
between-variations between-variations demonstrates variants of between, which outputs a value between configurable minimum and maximum bounds when it receives a bang.
satk.math.random2choices satk.math.random2choices randomly outputs one of two values, making it useful for probabilistic binary choices.
randrange randrange produces random numbers in the range from its first argument through one less than its second argument.
fd_wielevy fd_wielevy computes a Wiener–Lévy process, also identified in the help patch as the Ornstein–Uhlenbeck process, following Xenakis’ method 3 in Formalized Music.
brown-melody brown-melody generates a Brownian-motion-like melody within a specified note range for creating evolving pitch sequences.
prandom prandom provides random values using the standard C rand() function.
scale-changer scale-changer changes one pitch of a given scale at a time, allowing its harmony and active pitch classes to evolve.
sneak sneak makes a random selection from a supplied list when it receives a bang in its left inlet.
urandom urandom is an interface to the urandom utility that fetches three bytes.
list-random list-random generates a list of pseudorandom integers for use in control-list operations.
route.random route.random routes each incoming bang, float, symbol, list, or other message to a randomly selected outlet.
fd_norep fd_norep outputs a list of non-repeated random numbers when it receives a bang; its argument sets the list size, and a float can provide a new size.
series series works with a supplied list and, when banged, reports a random element along with its current index; the help patch also indicates when its urn is refilled.
xrandom xrandom outputs random integers without repetition.
random_tw random_tw is a control-rate random-number generator that outputs floats, shown with lower and upper limit creation arguments such as random_tw 0 1.
fd_salvo fd_salvo outputs a random number from 0 to N, where N is set by its argument, while excluding the input number.
rnd_metro rnd_metro is a metronome that outputs bangs with a random delay between successive bangs.
fd_rnd fd_rnd is a noise~-based random integer generator that outputs a random integer when it receives a bang.
rand_diff rand_diff outputs random numbers with very little redundancy, with values described as mostly increasing.
shuffle jmmmp/shuffle is a no-repeat random integer generator that outputs a shuffled integer series when it receives a bang.
brownian brownian is a random generator based on Brownian movement, with minimum, maximum, and Brownian-factor parameters.
dist_normal dist_normal generates control-rate random floats with a normal distribution centered at mean 0 and having standard deviation 1.
choose-intervals choose-intervals chooses a supply of one to five different intervals for use in generating pitch material.
fd_markfour fd_markfour implements a fourth-order Markov chain, calculating and outputting the next state as a list when its first inlet receives a bang.
random.pw_lin random.pw_lin generates random floating-point values from a piecewise linear distribution defined by interleaved interval boundaries and boundary probabilities.
pdp_randmix pdp_randmix randomly crossfades between two packets.
16step-seq 16step-seq is a 16-step rhythm sequencer that outputs bangs for active steps and indicates when the sequence has finished.
array-shuffle array-shuffle shuffles the contents of an array, as demonstrated with the routetable array to create random routing.
choose choose randomly selects elements from a supplied list.
rnd_flow rnd_flow produces a filtered random output, intended for generating smoothly varying random values.
between-log between-log outputs a random number when it receives a bang or any other input in its left inlet.
probabilizer probabilizer outputs a pseudo-random value from 1 to the number of elements in a supplied list.
mtwister mtwister is a Mersenne Twister pseudorandom real-number generator that outputs a new value when it receives a bang.
tripleRand tripleRand generates three distinct random numbers and outputs them as a list.
random.atom random.atom outputs a randomly chosen atom from a specified list when it receives a bang, with optional per-atom weights.
random_fl random_fl is a control-rate linear congruential random-number generator that outputs floats.
list.shuffle list.shuffle randomly rearranges the elements of an input list and outputs a new shuffled list.
ls.scramble ls.scramble is a vanilla abstraction that randomly rearranges the elements of an input list and outputs the scrambled list.
groups groups chooses elements from a supplied integer list to form a group.
rand rand is similar to random, producing a random value from a range with one argument or between start/stop boundaries with two arguments; three or more arguments define a list from which it selects.
markov-harmony markov-harmony generates a sequence of intervals using a one-dimensional Markov process, for producing pitch-class harmony.
random_icg random_icg is an inverse linear congruential random-number generator that outputs floats.
random-row random-row generates a random twelve-tone row.
fd_mark fd_mark is a Markov-chain generator with a variable number of states, outputting the current state as a float.
sneak-rhythm sneak-rhythm generates a rhythm that “sneaks” between neighbouring values, with minimum and maximum event-duration (ED) limits.
jp.urn jp.urn generates unrepeated random numbers, like Cyclone’s urn, within a range set by its creation argument.
poisson poisson generates Poisson-distributed random numbers for control use, outputting a float when it receives a bang.
list.choice list.choice outputs a randomly selected element from an input list or mlist, making it useful when a patch needs a random choice from supplied data.
fd_r fd_r randomly chooses a float from its creation arguments, a named array, or a list supplied through the second inlet.
between between outputs a float between a minimum and maximum value.
pmtwister pmtwister is a random number generator that selects prime numbers.
array-scramble array-scramble randomizes the order of values in the currently referenced array when it receives a bang.
array-random-walk array-random-walk fills the currently referenced array with random-walk data when its first inlet receives a list containing the starting value, maximum step magnitude, lower limit, and upper limit.
gauss gauss generates Gaussian-distributed random numbers for control use, outputting the next value as a float when it receives a bang.
rmetro rmetro (short for random metro) is a metronome that outputs a bang on each tick while adding a random value, up to a specified maximum, to its base period.
fd_mtxdelit fd_mtxdelit randomly delay-iterates a 3×1 matrix, accepting either a bang to begin iteration or a list whose first three elements form the matrix.
rand.dev rand.dev generates random values that deviate from an input value within a specified range.
periodic periodic is a seedable random-number generator with an upper-limit argument and a periodicity-factor argument, as illustrated by periodic 10 0.5.
mtx_rand mtx_rand fills a matrix with random values in the range (0, 1].
metro.wchoice metro.wchoice outputs bangs at intervals chosen randomly from a set of positive times in milliseconds, using an associated list of weights.
beta beta generates beta-distributed random numbers for control use, outputting a float each time its left inlet receives a bang.
probalizer probalizer outputs a series of integers according to configurable probabilities, without repetitions and with a maximum number of occurrences per series.
listRandom listRandom takes a list and outputs one of its elements.
random.linear random.linear generates random numbers with a linear distribution in the interval [@v0, @v1), outputting a new value when it receives a bang.
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.
mtx_randperm mtx_randperm generates a random permutation matrix for control-rate matrix processing.
expo expo generates exponentially distributed random control values.
brown-rhythm brown-rhythm generates a Brownian-movement-like rhythm from a geometrical series of ED values.
crand crand outputs a random floating-point value when it receives a bang, within a range set by its minimum and maximum creation arguments.
listShuffle listShuffle randomizes the positions of elements in a list.
random-ramp random-ramp generates randomly fluctuating envelope shapes by choosing random ramp durations and velocity destinations.
random-gates random-gates generates random trigger/gate signals for use as an output.
metro.random metro.random outputs bangs at uniformly distributed random intervals between specified minimum and maximum times in milliseconds.
fd_dataWalk fd_dataWalk performs a random walk into a data-structure array and is intended for use with fd_data.
addNoise addNoise takes a number and adds a random number to it, providing a simple way to introduce noise into numeric values.
choice-rhythm choice-rhythm creates a rhythmic choice from a supplied set of entry-delay (ED) values and outputs a list of the chosen indices.
random.pw_const random.pw_const generates floating-point random numbers from a piecewise-constant distribution defined by interleaved interval boundaries and weights.
sneak-random sneak-random outputs a random number from 0 to n−1, with n supplied as its creation argument (for example, sneak-random 7).
random-ramp-urn random-ramp-urn generates randomly fluctuating envelope shapes by choosing random ramp durations and velocity destinations.
list-wrandom list-wrandom uses an input list as a probability table for weighted random selection.
randomList randomList takes a number and outputs a list of random values.
fd_markov3 fd_markov3 implements a Markov chain and outputs states as floats.
chanceBang chanceBang outputs a bang according to a specified percentage chance, making it useful for probabilistic triggering.
random.int random.int generates pseudo-random integers uniformly within a specified closed interval; a bang generates a new value, while gen N produces a list of N integers.
rtrig~ rtrig~ randomly generates click triggers, providing a stochastic trigger source.
markov-rhythm markov-rhythm generates rhythms from the entry delays of supplied rhythmic material using a Markov matrix, supporting probabilistic transitions and repetitions.
randomF randomF is a floating-point random number generator for control-rate use.
metro-dev% metro-dev% introduces percentage-based timing irregularities into an otherwise equal pulsation.
fd_s-prob-5 fd_s-prob-5 selects among five states according to defined probabilities, for use in Markov chains, and outputs a bang from the selected state's outlet.
lurn lurn is a unique random-number generator that outputs each value in its configured range without repetition, stopping and banging its right outlet once all values have been chosen.
randy randy outputs a random integer and is similar to Pd’s random object.
percussion percussion is a synthesized three-operator FM percussion module that produces audio at its OUT output when triggered through its TRIG gate input.
weibull weibull generates Weibull-distributed random floating-point numbers for control-rate use.
alea-rhythm alea-rhythm outputs rhythm bangs at random times for generating an aleatoric rhythm.
weightedRandom weightedRandom takes a list of alternating elements and weights, then outputs a random element according to those weights.
triang triang generates triangularly distributed random control values and outputs each result as a float.
percent percent conditionally sends input to its left outlet according to a percentage supplied at the right inlet, using a pseudorandom decision.
probability probability is a probability-logic module that controls the probability of an input signal passing to either of its two outputs.
prop.random prop.random is a property randomizer that generates new random values for a specified list of property names, intended to connect to a target object.
random1 random1 is a control-rate linear congruential random-number generator that outputs floats.
super-rhythm super-rhythm is a rhythm model that generates rhythms from a supplied collection of entry delays (EDs), with selectable patterns and selection principles such as alea, series, sequence, and rota.
frand frand outputs a random floating-point number when it receives a bang, using a range set by minimum and maximum creation arguments; without arguments, the range defaults to 0–1.
array.rand array.rand populates an array with random floating-point values between specified low and high bounds, using a specified step size.