This is the cl-patterns Reference Manual, version 0.7, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 15:33:36 2024 GMT+0.
cl-patterns/cl-patterns.asdcl-patterns/package.lispcl-patterns/utility.lispcl-patterns/conversions.lispcl-patterns/scales.lispcl-patterns/event.lispcl-patterns/patterns/patterns.lispcl-patterns/patterns/pdef.lispcl-patterns/patterns/pmeta.lispcl-patterns/patterns/bjorklund.lispcl-patterns/patterns/cycles.lispcl-patterns/patterns/track.lispcl-patterns/patterns/export.lispcl-patterns/eseq.lispcl-patterns/backend.lispcl-patterns/render.lispcl-patterns/clock.lispcl-patterns/extensions/sequence.lispThe main system appears first, followed by any subsystem dependency.
cl-patternsPattern library for algorithmic music composition and performance in Common Lisp
modula t.
(GIT git@github.com:defaultxr/cl-patterns.git)
MIT
0.7
alexandria (system).
mutility (system).
mutility/loopy (system).
bordeaux-threads (system).
closer-mop (system).
named-readtables (system).
local-time (system).
dissect (system).
package.lisp (file).
utility.lisp (file).
conversions.lisp (file).
scales.lisp (file).
event.lisp (file).
patterns (module).
eseq.lisp (file).
backend.lisp (file).
render.lisp (file).
clock.lisp (file).
extensions/sequence.lisp (file).
Modules are listed depth-first from the system components tree.
cl-patterns/patternsevent.lisp (file).
cl-patterns (system).
patterns.lisp (file).
pdef.lisp (file).
pmeta.lisp (file).
bjorklund.lisp (file).
cycles.lisp (file).
track.lisp (file).
export.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
cl-patterns/cl-patterns.asdcl-patterns/package.lispcl-patterns/utility.lispcl-patterns/conversions.lispcl-patterns/scales.lispcl-patterns/event.lispcl-patterns/patterns/patterns.lispcl-patterns/patterns/pdef.lispcl-patterns/patterns/pmeta.lispcl-patterns/patterns/bjorklund.lispcl-patterns/patterns/cycles.lispcl-patterns/patterns/track.lispcl-patterns/patterns/export.lispcl-patterns/eseq.lispcl-patterns/backend.lispcl-patterns/render.lispcl-patterns/clock.lispcl-patterns/extensions/sequence.lispcl-patterns/utility.lisppackage.lisp (file).
cl-patterns (system).
*clock* (special variable).
*event* (special variable).
all-instruments (function).
beat (generic function).
end (generic function).
end-quant (generic function).
ended-p (generic function).
eop (special variable).
eop-p (generic function).
launch (generic function).
loop-p (generic function).
multi-channel-funcall (function).
next-beat-for-quant (function).
note-name-and-octave (function).
pattern (method combination).
play (generic function).
play-or-end (function).
play-or-stop (function).
play-quant (generic function).
play-solo (function).
play-swap (function).
playing-nodes (function).
playing-p (generic function).
pyramid (function).
quant (generic function).
(setf quant) (method).
rerange (function).
rest-p (generic function).
stop (generic function).
tempo (generic function).
transpose (function).
*dictionary-lookup-functions* (special variable).
cumulative-list (function).
find-buffer-symbol (function).
find-object-by-id (function).
from-range (function).
index-of-greater-than (function).
last-dur (generic function).
mapcar-longest (function).
near-p (function).
nearest (function).
normalized-sum (function).
pattern-pstream-class-name (function).
plist-set (function).
string-replace (function).
to-range (function).
cl-patterns/conversions.lisputility.lisp (file).
cl-patterns (system).
*c4-midinote* (special variable).
*note-names* (special variable).
amp-db (function).
bipolar-1-to-midi (function).
bipolar-unipolar (function).
chromatic-index-degree (function).
chromatic-index-freq (function).
chromatic-index-midinote (function).
chromatic-index-note (function).
db-amp (function).
degree-chromatic-index (function).
degree-freq (function).
degree-key (function).
degree-midinote (function).
degree-note (function).
degree-octave (function).
dur-freq (function).
dur-time (function).
freq-chromatic-index (function).
freq-degree (function).
freq-dur (function).
freq-midinote (function).
freq-note (function).
freq-octave (function).
freq-rate (function).
frequency-to-midi (function).
midi-ratio (function).
midi-truncate-clamp (function).
midinote-chromatic-index (function).
midinote-degree (function).
midinote-freq (function).
midinote-note (function).
midinote-octave (function).
midinote-rate (function).
note-chromatic-index (function).
note-degree (function).
note-freq (function).
note-midinote (function).
note-octave (function).
octave-degree (function).
octave-freq (function).
octave-midinote (function).
octave-note (function).
rate-freq (function).
rate-midinote (function).
ratio-midi (function).
time-dur (function).
unipolar-1-to-midi (function).
unipolar-bipolar (function).
*conversions* (special variable).
boolean-to-midi (function).
defconversion (macro).
cl-patterns/scales.lispconversions.lisp (file).
cl-patterns (system).
all-chords (function).
all-scales (function).
all-tunings (function).
chord (generic function).
chord (class).
chord-indexes (generic function).
(setf chord-indexes) (writer method).
chord-midinotes (function).
chord-name (generic function).
(setf chord-name) (writer method).
chord-notes (function).
chord-scale (generic function).
(setf chord-scale) (writer method).
define-chord (function).
define-scale (function).
define-tuning (function).
describe-object (method).
load-scala-scale (function).
print-object (method).
print-object (method).
print-object (method).
scale (generic function).
scale (class).
scale-midinotes (function).
scale-name (generic function).
(setf scale-name) (writer method).
scale-notes (generic function).
(setf scale-notes) (writer method).
scale-steps-per-octave (generic function).
scale-tuning (generic function).
(setf scale-tuning) (writer method).
tone-matrix (function).
tuning (generic function).
tuning (class).
tuning-name (generic function).
(setf tuning-name) (writer method).
tuning-octave-ratio (generic function).
(setf tuning-octave-ratio) (writer method).
tuning-pitches (generic function).
(setf tuning-pitches) (writer method).
tuning-steps-per-octave (generic function).
*abbreviations* (special variable).
*chords* (special variable).
*scales* (special variable).
*tunings* (special variable).
generate-aliases (function).
index-and-offset (function).
sharp-or-flat (function).
cl-patterns/event.lispscales.lisp (file).
cl-patterns (system).
amp (generic function).
(setf amp) (method).
beat (method).
(setf beat) (method).
combine-events (function).
combine-events-via-lists (function).
copy-event (function).
db (generic function).
(setf db) (method).
delta (generic function).
(setf delta) (method).
dur (generic function).
(setf dur) (method).
e (function).
(setf e) (function).
eop-p (method).
event (function).
event (class).
event-equal (function).
event-p (function).
event-plist (generic reader).
event-value (function).
(setf event-value) (function).
events-differing-keys (function).
events-lists-differing-keys (compiler macro).
events-lists-differing-keys (function).
every-event-equal (function).
freq (generic function).
(setf freq) (method).
instrument (generic function).
(setf instrument) (method).
keys (method).
legato (generic function).
(setf legato) (method).
loop-p (method).
(setf loop-p) (method).
midinote (generic function).
(setf midinote) (method).
pan (generic function).
(setf pan) (method).
play (method).
play-quant (method).
(setf play-quant) (method).
print-object (method).
quant (method).
(setf quant) (method).
rate (generic function).
(setf rate) (method).
remove-event-value (function).
rest-p (method).
(setf rest-p) (method).
scale (method).
(setf scale) (method).
split-event-by-lists (function).
sustain (generic function).
(setf sustain) (method).
tempo (method).
(setf tempo) (method).
%beat (reader method).
(setf %beat) (function).
*deprecated-function-error-events-lists-differing-keys-notified-p* (special variable).
*event-special-keys* (special variable).
define-event-special-key (macro).
raw-event-value (function).
(setf raw-event-value) (function).
cl-patterns/patterns/patterns.lisppatterns (module).
*default-pattern-length* (special variable).
*default-pattern-repeats* (special variable).
*display-server* (special variable).
*max-pattern-yield-length* (special variable).
*post-pattern-output-processors* (special variable).
*screen-size* (special variable).
all-patterns (function).
as-pstream (generic function).
beat (reader method).
bsubseq (generic function).
defpattern (macro).
dur (method).
end-quant (reader method).
(setf end-quant) (writer method).
ended-p (method).
initialize-instance (method).
initialize-instance (method).
initialize-instance (method).
initialize-instance (method).
initialize-instance (method).
initialize-instance (method).
instrument-mapping (function).
(setf instrument-mapping) (function).
ipstream (function).
ipstream (class).
ipstream-insert (generic function).
ipstream-pstream (class).
keys (method).
launch (method).
loop-p (method).
loop-p (method).
(setf loop-p) (method).
mouse-location (function).
next (generic function).
next-n (function).
next-upto-n (function).
p* (function).
p+ (function).
p- (function).
p/ (function).
p/= (function).
p< (function).
p<= (function).
p= (function).
p> (function).
p>= (function).
paccum (function).
paccum (class).
paccum-pstream (class).
paclump (function).
paclump (class).
paclump-pstream (class).
parp (function).
parp (class).
parp-pstream (class).
pattern (class).
pattern-as-pstream (function).
pattern-children (function).
pattern-metadata (generic function).
(setf pattern-metadata) (function).
pattern-p (function).
pattern-parent (function).
pattern-source (generic reader).
(setf pattern-source) (writer method).
pb (macro).
pbeat (function).
pbeat (class).
pbeat* (function).
pbeat* (class).
pbeat*-pstream (class).
pbeat-pstream (class).
pbind (function).
pbind (class).
pbind-pstream (class).
pbrown (function).
pbrown (class).
pbrown-pstream (class).
pchain (function).
pchain (class).
pchain-pstream (class).
pclump (function).
pclump (class).
pclump-pstream (class).
pdelta (function).
pdelta (class).
pdelta-pstream (class).
pdiff (function).
pdiff (class).
pdiff-pstream (class).
pdrop (function).
pdrop (class).
pdrop-pstream (class).
pdurstutter (function).
pdurstutter (class).
pdurstutter-pstream (class).
peek (generic function).
peek-n (function).
peek-upto-n (function).
peql (function).
pexprand (function).
pexprand (class).
pexprand-pstream (class).
pf (macro).
pfilter (function).
pfilter (class).
pfilter-out (function).
pfilter-pstream (class).
pfin (function).
pfin (class).
pfin-pstream (class).
pfindur (function).
pfindur (class).
pfindur-pstream (class).
pfunc (function).
pfunc (class).
pfunc-pstream (class).
pgauss (function).
pgauss (class).
pgauss-pstream (class).
pgeom (function).
pgeom (class).
pgeom* (function).
pgeom-pstream (class).
phistory (function).
phistory (class).
phistory-pstream (class).
pif (function).
pif (class).
pif-pstream (class).
pindex (function).
pindex (class).
pindex-pstream (class).
pk (function).
pk (class).
pk-pstream (class).
place (function).
place (class).
place-pstream (class).
play (method).
play-quant (method).
(setf play-quant) (method).
playing-p (method).
plazy (function).
plazy (class).
plazy-pstream (class).
pmono (function).
pmouse (function).
pmouse (class).
pmouse-pstream (class).
pmousex (function).
pmousey (function).
pn (function).
pn (class).
pn-pstream (class).
pnary (function).
pnary (class).
pnary-pstream (class).
ppar (function).
ppar (class).
ppar-pstream (class).
pparchain (function).
pparchain (class).
pparchain-pstream (class).
ppatlace (function).
ppatlace (class).
ppatlace-pstream (class).
ppc (macro).
pr (function).
pr (class).
pr-pstream (class).
prand (function).
prand (class).
prand-pstream (class).
prerange (function).
prerange (class).
prerange-pstream (class).
prest (function).
prest (class).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
print-object (method).
protate (function).
protate (class).
protate-pstream (class).
prs (function).
prun (function).
prun (class).
prun-pstream (class).
ps (function).
ps (class).
ps-pstream (class).
pscratch (function).
pscratch (class).
pscratch-pstream (class).
pseq (function).
pseq (class).
pseq-pstream (class).
pser (function).
pser (class).
pser-pstream (class).
pseries (function).
pseries (class).
pseries* (function).
pseries-pstream (class).
pshuf (function).
pshuf (class).
pshuf-pstream (class).
pslide (function).
pslide (class).
pslide-pstream (class).
pstream (class).
pstream-count (generic reader).
(setf pstream-count) (writer method).
(setf pstream-count) (writer method).
pstream-elt (function).
pstream-elt-future (function).
pstream-p (function).
psym (function).
psym (class).
psym-pstream (class).
psync (function).
psync (class).
psync-pstream (class).
ptime (function).
ptime (class).
ptime-pstream (class).
ptrace (function).
ptrace (class).
ptrace-pstream (class).
pts (function).
pts (class).
pts-pstream (class).
pwalk (function).
pwalk (class).
pwalk-pstream (class).
pwhite (function).
pwhite (class).
pwhite-pstream (class).
pwrand (function).
pwrand (class).
pwrand-pstream (class).
pwrap (function).
pwxrand (function).
pwxrand (class).
pwxrand-pstream (class).
pxrand (function).
pxrand (class).
pxrand-pstream (class).
rest-p (method).
screen-size (function).
t-pstream (function).
t-pstream (class).
t-pstream-length (generic reader).
(setf t-pstream-length) (writer method).
t-pstream-p (function).
t-pstream-value (generic reader).
(setf t-pstream-value) (writer method).
%pattern-children (method).
%pattern-children (method).
%pattern-children (method).
*instrument-map* (special variable).
*pattern-function-translations* (special variable).
*patterns* (special variable).
*pbind-special-init-keys* (special variable).
*pbind-special-process-keys* (special variable).
*pbind-special-wrap-keys* (special variable).
decf-remaining (function).
define-pattern-function-translation (macro).
define-pbind-special-init-key (macro).
define-pbind-special-process-key (macro).
define-pbind-special-wrap-key (macro).
end-condition (reader method).
(setf end-condition) (writer method).
events-in-range (generic function).
last-output (generic function).
make-default-event (function).
make-pattern-for-function (function).
mouse-location* (generic function).
pattern-translate-sexp (function).
pb-translate-body-functions (function).
pbind-pairs (reader method).
(setf pbind-pairs) (writer method).
pstream-elt-index (reader method).
pstream-elt-index-to-history-index (function).
pstream-history-advance-by (function).
pstream-out-of-range (condition).
remaining-p (function).
remap-instrument-to-parameters (function).
screen-size* (generic function).
set-parents (function).
value-remaining-p (function).
cl-patterns/patterns/pdef.lisppatterns (module).
all-pdef-names (function).
all-pdefs (function).
as-pstream (method).
end (method).
end-quant (method).
find-pdef (function).
(setf find-pdef) (function).
keys (method).
launch (method).
loop-p (method).
next (method).
pdef (function).
pdef (class).
pdef-name (generic function).
(setf pdef-name) (method).
(setf pdef-name) (method).
pdef-p (function).
pdef-pattern (generic function).
(setf pdef-pattern) (writer method).
pdef-pstream (generic function).
(setf pdef-pstream) (method).
(setf pdef-pstream) (writer method).
pdef-pstream (class).
pdef-task (generic function).
(setf pdef-task) (writer method).
play (method).
play-quant (method).
playing-p (method).
playing-pdef-names (function).
playing-pdefs (function).
print-object (method).
print-object (method).
stop (method).
*pdef-dictionary* (special variable).
pdef-names (function).
cl-patterns/patterns/pmeta.lisppatterns (module).
as-pstream (method).
next (method).
pmeta (function).
pmeta (class).
pmeta-pstream (class).
print-object (method).
pmeta-ensure-pattern-value (function).
process-pattern-key-value (generic function).
cl-patterns/patterns/bjorklund.lisppatterns (module).
as-pstream (method).
bjorklund (function).
next (method).
pbjorklund (function).
pbjorklund (class).
pbjorklund-pstream (class).
print-object (method).
cl-patterns/patterns/cycles.lisppatterns (module).
as-pstream (method).
cycles (macro).
next (method).
pcycles (function).
pcycles (class).
pcycles-pstream (class).
print-object (method).
cycles-parse (function).
pcycles-parse-list (function).
cl-patterns/patterns/track.lisppatterns (module).
as-pstream (method).
next (method).
print-object (method).
pt (macro).
ptrack (function).
ptrack (class).
ptrack-cell (generic function).
(setf ptrack-cell) (generic function).
ptrack-pstream (class).
ptrack-row (generic function).
(setf ptrack-row) (method).
ptrack-rows (generic function).
ptrack-does-not-exist (function).
string-reader (function).
t-short (function).
track-shorthand (function).
cl-patterns/eseq.lisppatterns (module).
cl-patterns (system).
as-eseq (generic function).
as-pstream (method).
bsubseq (method).
bsubseq (method).
dur (method).
end-quant (method).
(setf end-quant) (method).
eseq (function).
eseq (class).
eseq-add (generic function).
eseq-events (generic reader).
(setf eseq-events) (method).
eseq-length (function).
eseq-p (function).
eseq-pstream (class).
eseq-remove (generic function).
loop-p (method).
(setf loop-p) (method).
next (method).
pattern-metadata (method).
play-quant (method).
(setf play-quant) (method).
print-object (method).
last-dur (method).
next.events-ordered (method).
cl-patterns/backend.lispeseq.lisp (file).
cl-patterns (system).
all-backend-types (function).
all-backends (function).
backend (class).
backend-p (function).
backend-start (generic function).
backend-stop (generic function).
enabled-backends (function).
find-backend (function).
initialize-instance (method).
make-backend (generic function).
*backends* (special variable).
backend-all-instruments (generic function).
backend-all-nodes (generic function).
backend-control-node-at (generic function).
backend-convert-object (generic function).
backend-enabled-p (reader method).
(setf backend-enabled-p) (writer method).
backend-input-processors (reader method).
(setf backend-input-processors) (writer method).
backend-instrument-args-list (generic function).
backend-instrument-controls (generic function).
backend-instrument-has-gate-p (function).
backend-metadata (reader method).
(setf backend-metadata) (writer method).
backend-name (reader method).
(setf backend-name) (writer method).
backend-node-p (generic function).
backend-panic (generic function).
backend-play-event (generic function).
backend-proxys-node (generic function).
backend-responds-p (generic function).
backend-started-p (reader method).
(setf backend-started-p) (writer method).
backend-task-added (generic function).
backend-task-removed (generic function).
backend-tempo-change-at (generic function).
backend-timestamps-for-event (generic function).
event-backends (function).
task-nodes (function).
(setf task-nodes) (function).
cl-patterns/render.lispbackend.lisp (file).
cl-patterns (system).
*cl-patterns-temporary-directory* (special variable).
render (generic function).
find-backend-supporting-render (function).
cl-patterns/clock.lisprender.lisp (file).
cl-patterns (system).
beat (reader method).
beat (method).
(setf beat) (writer method).
clock-caught-conditions (function).
(setf clock-caught-conditions) (function).
clock-condition-handler (function).
(setf clock-condition-handler) (function).
clock-latency (function).
(setf clock-latency) (function).
clock-loop (function).
clock-process (function).
clock-tasks (function).
(setf clock-tasks) (function).
end (method).
loop-p (method).
make-clock (function).
pattern-tasks (function).
playing-p (method).
print-object (method).
print-object (method).
start-clock-loop (function).
stop (method).
task-pattern (function).
tempo (method).
tempo (reader method).
(setf tempo) (method).
absolute-beats-to-timestamp (function).
can-swap-now-p (function).
clock (class).
clock-add (function).
clock-clear-tasks (function).
clock-process-event (function).
clock-remove (function).
event-with-raw-timing (function).
real-beat (method).
task (class).
task-clock (reader method).
(setf task-clock) (writer method).
task-item (reader method).
(setf task-item) (writer method).
cl-patterns/extensions/sequence.lispclock.lisp (file).
cl-patterns (system).
Packages are listed by definition order.
cl-patternsalexandria.
common-lisp.
mutility.
*c4-midinote* (special variable).
*cl-patterns-temporary-directory* (special variable).
*clock* (special variable).
*default-pattern-length* (special variable).
*default-pattern-repeats* (special variable).
*display-server* (special variable).
*event* (special variable).
*max-pattern-yield-length* (special variable).
*note-names* (special variable).
*post-pattern-output-processors* (special variable).
*screen-size* (special variable).
all-backend-types (function).
all-backends (function).
all-chords (function).
all-instruments (function).
all-patterns (function).
all-pdef-names (function).
all-pdefs (function).
all-scales (function).
all-tunings (function).
amp (generic function).
(setf amp) (generic function).
amp-db (function).
as-eseq (generic function).
as-pstream (generic function).
backend (class).
backend-p (function).
backend-start (generic function).
backend-stop (generic function).
beat (generic function).
(setf beat) (generic function).
bipolar-1-to-midi (function).
bipolar-unipolar (function).
bjorklund (function).
bsubseq (generic function).
chord (generic function).
chord (class).
chord-indexes (generic function).
(setf chord-indexes) (generic writer).
chord-midinotes (function).
chord-name (generic function).
(setf chord-name) (generic writer).
chord-notes (function).
chord-scale (generic function).
(setf chord-scale) (generic writer).
chromatic-index-degree (function).
chromatic-index-freq (function).
chromatic-index-midinote (function).
chromatic-index-note (function).
clock-caught-conditions (function).
(setf clock-caught-conditions) (function).
clock-condition-handler (function).
(setf clock-condition-handler) (function).
clock-latency (function).
(setf clock-latency) (function).
clock-loop (function).
clock-process (function).
clock-tasks (function).
(setf clock-tasks) (function).
combine-events (function).
combine-events-via-lists (function).
copy-event (function).
cycles (macro).
db (generic function).
(setf db) (generic function).
db-amp (function).
define-chord (function).
define-scale (function).
define-tuning (function).
defpattern (macro).
degree-chromatic-index (function).
degree-freq (function).
degree-key (function).
degree-midinote (function).
degree-note (function).
degree-octave (function).
delta (generic function).
(setf delta) (generic function).
dur (generic function).
(setf dur) (generic function).
dur-freq (function).
dur-time (function).
e (function).
(setf e) (function).
enabled-backends (function).
end (generic function).
end-quant (generic function).
(setf end-quant) (generic function).
ended-p (generic function).
eop (special variable).
eop-p (generic function).
eseq (function).
eseq (class).
eseq-add (generic function).
eseq-events (generic reader).
(setf eseq-events) (generic function).
eseq-length (function).
eseq-p (function).
eseq-pstream (class).
eseq-remove (generic function).
event (function).
event (class).
event-equal (function).
event-p (function).
event-plist (generic reader).
event-value (function).
(setf event-value) (function).
events-differing-keys (function).
events-lists-differing-keys (compiler macro).
events-lists-differing-keys (function).
every-event-equal (function).
find-backend (function).
find-pdef (function).
(setf find-pdef) (function).
freq (generic function).
(setf freq) (generic function).
freq-chromatic-index (function).
freq-degree (function).
freq-dur (function).
freq-midinote (function).
freq-note (function).
freq-octave (function).
freq-rate (function).
frequency-to-midi (function).
instrument (generic function).
(setf instrument) (generic function).
instrument-mapping (function).
(setf instrument-mapping) (function).
ipstream (function).
ipstream (class).
ipstream-insert (generic function).
ipstream-pstream (class).
launch (generic function).
legato (generic function).
(setf legato) (generic function).
load-scala-scale (function).
loop-p (generic function).
(setf loop-p) (generic function).
make-backend (generic function).
make-clock (function).
midi-ratio (function).
midi-truncate-clamp (function).
midinote (generic function).
(setf midinote) (generic function).
midinote-chromatic-index (function).
midinote-degree (function).
midinote-freq (function).
midinote-note (function).
midinote-octave (function).
midinote-rate (function).
mouse-location (function).
multi-channel-funcall (function).
next (generic function).
next-beat-for-quant (function).
next-n (function).
next-upto-n (function).
note-chromatic-index (function).
note-degree (function).
note-freq (function).
note-midinote (function).
note-name-and-octave (function).
note-octave (function).
octave-degree (function).
octave-freq (function).
octave-midinote (function).
octave-note (function).
p* (function).
p+ (function).
p- (function).
p/ (function).
p/= (function).
p< (function).
p<= (function).
p= (function).
p> (function).
p>= (function).
paccum (function).
paccum (class).
paccum-pstream (class).
paclump (function).
paclump (class).
paclump-pstream (class).
pan (generic function).
(setf pan) (generic function).
parp (function).
parp (class).
parp-pstream (class).
pattern (method combination).
pattern (class).
pattern-as-pstream (function).
pattern-children (function).
pattern-metadata (generic function).
(setf pattern-metadata) (function).
pattern-p (function).
pattern-parent (function).
pattern-source (generic reader).
(setf pattern-source) (generic writer).
pattern-tasks (function).
pb (macro).
pbeat (function).
pbeat (class).
pbeat* (function).
pbeat* (class).
pbeat*-pstream (class).
pbeat-pstream (class).
pbind (function).
pbind (class).
pbind-pstream (class).
pbjorklund (function).
pbjorklund (class).
pbjorklund-pstream (class).
pbrown (function).
pbrown (class).
pbrown-pstream (class).
pchain (function).
pchain (class).
pchain-pstream (class).
pclump (function).
pclump (class).
pclump-pstream (class).
pcycles (function).
pcycles (class).
pcycles-pstream (class).
pdef (function).
pdef (class).
pdef-name (generic function).
(setf pdef-name) (generic function).
pdef-p (function).
pdef-pattern (generic function).
(setf pdef-pattern) (generic writer).
pdef-pstream (generic function).
(setf pdef-pstream) (generic function).
pdef-pstream (class).
pdef-task (generic function).
(setf pdef-task) (generic writer).
pdelta (function).
pdelta (class).
pdelta-pstream (class).
pdiff (function).
pdiff (class).
pdiff-pstream (class).
pdrop (function).
pdrop (class).
pdrop-pstream (class).
pdurstutter (function).
pdurstutter (class).
pdurstutter-pstream (class).
peek (generic function).
peek-n (function).
peek-upto-n (function).
peql (function).
pexprand (function).
pexprand (class).
pexprand-pstream (class).
pf (macro).
pfilter (function).
pfilter (class).
pfilter-out (function).
pfilter-pstream (class).
pfin (function).
pfin (class).
pfin-pstream (class).
pfindur (function).
pfindur (class).
pfindur-pstream (class).
pfunc (function).
pfunc (class).
pfunc-pstream (class).
pgauss (function).
pgauss (class).
pgauss-pstream (class).
pgeom (function).
pgeom (class).
pgeom* (function).
pgeom-pstream (class).
phistory (function).
phistory (class).
phistory-pstream (class).
pif (function).
pif (class).
pif-pstream (class).
pindex (function).
pindex (class).
pindex-pstream (class).
pk (function).
pk (class).
pk-pstream (class).
place (function).
place (class).
place-pstream (class).
play (generic function).
play-or-end (function).
play-or-stop (function).
play-quant (generic function).
(setf play-quant) (generic function).
play-solo (function).
play-swap (function).
playing-nodes (function).
playing-p (generic function).
playing-pdef-names (function).
playing-pdefs (function).
plazy (function).
plazy (class).
plazy-pstream (class).
pmeta (function).
pmeta (class).
pmeta-pstream (class).
pmono (function).
pmouse (function).
pmouse (class).
pmouse-pstream (class).
pmousex (function).
pmousey (function).
pn (function).
pn (class).
pn-pstream (class).
pnary (function).
pnary (class).
pnary-pstream (class).
ppar (function).
ppar (class).
ppar-pstream (class).
pparchain (function).
pparchain (class).
pparchain-pstream (class).
ppatlace (function).
ppatlace (class).
ppatlace-pstream (class).
ppc (macro).
pr (function).
pr (class).
pr-pstream (class).
prand (function).
prand (class).
prand-pstream (class).
prerange (function).
prerange (class).
prerange-pstream (class).
prest (function).
prest (class).
protate (function).
protate (class).
protate-pstream (class).
prs (function).
prun (function).
prun (class).
prun-pstream (class).
ps (function).
ps (class).
ps-pstream (class).
pscratch (function).
pscratch (class).
pscratch-pstream (class).
pseq (function).
pseq (class).
pseq-pstream (class).
pser (function).
pser (class).
pser-pstream (class).
pseries (function).
pseries (class).
pseries* (function).
pseries-pstream (class).
pshuf (function).
pshuf (class).
pshuf-pstream (class).
pslide (function).
pslide (class).
pslide-pstream (class).
pstream (class).
pstream-count (generic reader).
(setf pstream-count) (generic writer).
pstream-elt (function).
pstream-elt-future (function).
pstream-p (function).
psym (function).
psym (class).
psym-pstream (class).
psync (function).
psync (class).
psync-pstream (class).
pt (macro).
ptime (function).
ptime (class).
ptime-pstream (class).
ptrace (function).
ptrace (class).
ptrace-pstream (class).
ptrack (function).
ptrack (class).
ptrack-cell (generic function).
(setf ptrack-cell) (generic function).
ptrack-pstream (class).
ptrack-row (generic function).
(setf ptrack-row) (generic function).
ptrack-rows (generic function).
pts (function).
pts (class).
pts-pstream (class).
pwalk (function).
pwalk (class).
pwalk-pstream (class).
pwhite (function).
pwhite (class).
pwhite-pstream (class).
pwrand (function).
pwrand (class).
pwrand-pstream (class).
pwrap (function).
pwxrand (function).
pwxrand (class).
pwxrand-pstream (class).
pxrand (function).
pxrand (class).
pxrand-pstream (class).
pyramid (function).
quant (generic function).
(setf quant) (generic function).
rate (generic function).
(setf rate) (generic function).
rate-freq (function).
rate-midinote (function).
ratio-midi (function).
remove-event-value (function).
render (generic function).
rerange (function).
rest-p (generic function).
(setf rest-p) (generic function).
scale (generic function).
(setf scale) (generic function).
scale (class).
scale-midinotes (function).
scale-name (generic function).
(setf scale-name) (generic writer).
scale-notes (generic function).
(setf scale-notes) (generic writer).
scale-steps-per-octave (generic function).
scale-tuning (generic function).
(setf scale-tuning) (generic writer).
screen-size (function).
split-event-by-lists (function).
start-clock-loop (function).
stop (generic function).
sustain (generic function).
(setf sustain) (generic function).
t-pstream (function).
t-pstream (class).
t-pstream-length (generic reader).
(setf t-pstream-length) (generic writer).
t-pstream-p (function).
t-pstream-value (generic reader).
(setf t-pstream-value) (generic writer).
task-pattern (function).
tempo (generic function).
(setf tempo) (generic function).
time-dur (function).
tone-matrix (function).
transpose (function).
tuning (generic function).
tuning (class).
tuning-name (generic function).
(setf tuning-name) (generic writer).
tuning-octave-ratio (generic function).
(setf tuning-octave-ratio) (generic writer).
tuning-pitches (generic function).
(setf tuning-pitches) (generic writer).
tuning-steps-per-octave (generic function).
unipolar-1-to-midi (function).
unipolar-bipolar (function).
%beat (generic reader).
(setf %beat) (function).
%pattern-children (generic function).
*abbreviations* (special variable).
*backends* (special variable).
*chords* (special variable).
*conversions* (special variable).
*deprecated-function-error-events-lists-differing-keys-notified-p* (special variable).
*dictionary-lookup-functions* (special variable).
*event-special-keys* (special variable).
*instrument-map* (special variable).
*pattern-function-translations* (special variable).
*patterns* (special variable).
*pbind-special-init-keys* (special variable).
*pbind-special-process-keys* (special variable).
*pbind-special-wrap-keys* (special variable).
*pdef-dictionary* (special variable).
*scales* (special variable).
*tunings* (special variable).
absolute-beats-to-timestamp (function).
backend-all-instruments (generic function).
backend-all-nodes (generic function).
backend-control-node-at (generic function).
backend-convert-object (generic function).
backend-enabled-p (generic reader).
(setf backend-enabled-p) (generic writer).
backend-input-processors (generic reader).
(setf backend-input-processors) (generic writer).
backend-instrument-args-list (generic function).
backend-instrument-controls (generic function).
backend-instrument-has-gate-p (function).
backend-metadata (generic reader).
(setf backend-metadata) (generic writer).
backend-name (generic reader).
(setf backend-name) (generic writer).
backend-node-p (generic function).
backend-panic (generic function).
backend-play-event (generic function).
backend-proxys-node (generic function).
backend-responds-p (generic function).
backend-started-p (generic reader).
(setf backend-started-p) (generic writer).
backend-task-added (generic function).
backend-task-removed (generic function).
backend-tempo-change-at (generic function).
backend-timestamps-for-event (generic function).
boolean-to-midi (function).
can-swap-now-p (function).
clock (class).
clock-add (function).
clock-clear-tasks (function).
clock-process-event (function).
clock-remove (function).
cumulative-list (function).
cycles-parse (function).
decf-remaining (function).
defconversion (macro).
define-event-special-key (macro).
define-pattern-function-translation (macro).
define-pbind-special-init-key (macro).
define-pbind-special-process-key (macro).
define-pbind-special-wrap-key (macro).
end-condition (generic reader).
(setf end-condition) (generic writer).
event-backends (function).
event-with-raw-timing (function).
events-in-range (generic function).
find-backend-supporting-render (function).
find-buffer-symbol (function).
find-object-by-id (function).
from-range (function).
generate-aliases (function).
index-and-offset (function).
index-of-greater-than (function).
last-dur (generic function).
last-output (generic function).
make-default-event (function).
make-pattern-for-function (function).
mapcar-longest (function).
mouse-location* (generic function).
near-p (function).
nearest (function).
next.events-ordered (generic function).
normalized-sum (function).
pattern-pstream-class-name (function).
pattern-translate-sexp (function).
pb-translate-body-functions (function).
pbind-pairs (generic reader).
(setf pbind-pairs) (generic writer).
pcycles-parse-list (function).
pdef-names (function).
plist-set (function).
pmeta-ensure-pattern-value (function).
process-pattern-key-value (generic function).
pstream-elt-index (generic reader).
pstream-elt-index-to-history-index (function).
pstream-history-advance-by (function).
pstream-out-of-range (condition).
ptrack-does-not-exist (function).
raw-event-value (function).
(setf raw-event-value) (function).
real-beat (generic function).
remaining-p (function).
remap-instrument-to-parameters (function).
screen-size* (generic function).
set-parents (function).
sharp-or-flat (function).
string-reader (function).
string-replace (function).
t-short (function).
task (class).
task-clock (generic reader).
(setf task-clock) (generic writer).
task-item (generic reader).
(setf task-item) (generic writer).
task-nodes (function).
(setf task-nodes) (function).
to-range (function).
track-shorthand (function).
value-remaining-p (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
The MIDI note number of note C, octave 4. This sets the global tuning of the various pitch conversion functions.
The default directory to store ‘render’ed files in.
The default clock to run tasks on.
The default value of a pattern’s LENGTH parameter.
The default value of a pattern’s REPEATS parameter.
The display server type that ‘mouse-location’ should default to. Attempts to auto-detect the correct display server on load.
The event special variable. Can be referenced inside a pattern’s code.
The default maximum number of events or values that will be used by functions like ‘next-n’ or patterns like ‘protate’, in order to prevent hangs caused by infinite-length patterns.
List of note names in the equal temperament 12-tone tuning.
List of functions that are applied as the last step of pattern output generation. Each output yielded by an "outermost" pattern (i.e. one without a ‘pattern-parent’) will be processed (along with the pstream as a second argument) through each function in this list, allowing for arbitrary transformations of the generated outputs. The return value of each function is used as the input to the next function, and the return value of the last function is used as the output yielded by the pattern.
This can be used, for example, to implement mappings from friendly instrument names to the full parameters needed to specify the instrument in question for backends such as MIDI which require it; in fact this feature is already implemented more conveniently with the setf-able ‘instrument-mapping’ function.
See also: ‘*instrument-map*’, ‘remap-instrument-to-parameters’
The combined size of all monitors plugged into the machine that cl-patterns is running on. If you add or remove displays after loading cl-patterns, you may have to update this variable. To set the correct value, run (setf *screen-size* (screen-size)).
See also: ‘*display-server*’, ‘screen-size’, ‘mouse-location’, ‘pmouse’
End Of Pattern; the symbol yielded by patterns after their last output.
Convenience macro to specify a rhythm or melody using symbols. Outputs a list of events with :type, :dur, and another parameter which is specifiable. Usually used to :embed into a pattern.
SPEC is a symbol representing the type of output you’re going to send. It can be midinote, freq, note, instrument, or buffer/bufnum. It can also be a list, which provides the spec as the first element, and keywords (such as :dur for the total dur) for the rest.
MAP is a plist specifying the mapping from symbols to SPEC’s parameter. It can be blank if you’re just making a melody. By default, the map includes keys that map - and _ to rests.
LIST is the actual pattern to generate.
Define a pattern. This macro automatically generates the pattern’s class, its pstream class, and the function to create an instance of the pattern, and makes them external in the cl-patterns package.
NAME is the name of the pattern. Typically a word or two that describes its function, prefixed with p.
SUPERCLASSES is a list of superclasses of the pattern. Most patterns just subclass the ’pattern’ class.
SLOTS is a list of slots that the pattern and pstreams derived from it have. Each slot can either be just a symbol, or a slot definition a la ‘defclass’. You can provide a default for the slot with the :initform key as usual, and you can set a slot as a state slot (which only appears in the pattern’s pstream class) by setting the :state key to t.
DOCUMENTATION is a docstring describing the pattern. We recommend providing at least one example, and a "See also" section to refer to similar pattern classes.
DEFUN can either be a full defun form for the pattern, or an expression which will be inserted into the pattern creation function prior to initialization of the instance. Typically you’d use this for inserting ‘assert’ statements, for example.
See also: ‘pattern’, ‘pdef’, ‘all-patterns’
pb is a convenience macro, wrapping the functionality of ‘pbind’ and ‘pdef’ while also providing additional syntax sugar. NAME is the name of the pattern (same as pbind’s :pdef key or ‘pdef’ itself), and PAIRS is the same as in regular pbind. If PAIRS is only one element, pb operates like ‘pdef’, otherwise it operates like ‘pbind’.
The expressions in PAIRS are also automatically translated to equivalent patterns if applicable; for example:
;; (pb :foo :bar (+ (pseries) (pseq (list -1 0 1))))
...is the same as:
;; (pb :foo :bar (p+ (pseries) (pseq (list -1 0 1))))
See also: ‘pbind’, ‘pdef’
Convenience macro for ‘pfunc’ that automatically wraps BODY in a lambda.
Syntax sugar for ‘pparchain’ that automatically splits PAIRS by :- symbols.
Example:
;; (ppc :foo (pseq (list 1 2 3) 1)
;; :-
;; :bar (p+ (pk :foo) 2))
;; ;=> (((EVENT :FOO 1) (EVENT :FOO 1 :BAR 3))
;; ((EVENT :FOO 2) (EVENT :FOO 2 :BAR 4))
;; ((EVENT :FOO 3) (EVENT :FOO 3 :BAR 5)))
See also: ‘pparchain’
Syntax sugar for ‘ptrack’. Avoids the need to quote or use ‘list’.
Example:
;; (pt (:foo 1 :bar (pseries) :dur 1/4)
;; (2) ; (:foo 2 :bar 0 :dur 1/4)
;; () ; (:foo 1 :bar 1 :dur 1/4)
;; (9 :bar 90) ; (:foo 9 :bar 90 :dur 1/2)
;; (-) ; extends the previous note by 1/4 beat
;; :r ; (:foo 1 :bar 4 :dur 1/4 :type :rest)
;; )
See also: ‘ptrack’
Get a list of names of all defined backend types. A backend type is any class that inherits from ‘backend’.
See also: ‘all-backends’, ‘enabled-backends’
Get a list of all backends made with ‘make-backend’ or ‘backend-start’. ENABLED-P and STARTED-P can be used to limit the results only to backends with matching status.
See also: ‘all-backend-types’, ‘enabled-backends’
Get a list of all defined chords.
Get a list of the names of all instruments defined for BACKEND, or all enabled backends if none specified.
See also: ‘playing-nodes’, ‘all-patterns’, ‘all-pdefs’, ‘enabled-backends’
Get a list of the names of all defined pattern classes.
See also: ‘all-pdefs’
Get a list of the names of all defined pdef objects.
See also: ‘all-pdefs’, ‘pdef-names’
Get a list of all defined pdef objects in DICTIONARY. With PACKAGE, get only pdefs whose name is a symbol in that package.
See also: ‘all-pdef-names’, ‘pdef-names’, ‘find-pdef’
Get a list of all defined scales.
Get a list of all defined tunings.
Convert amplitude to decibels.
Test whether OBJECT is a ‘backend’.
See also: ‘find-backend’, ‘all-backends’
Convert the range -1..1 to 0..127.
Convert a bipolar number (-1 to 1) to a unipolar number (0 to 1).
See also: ‘unipolar-bipolar’
Generate a list representing a Euclidean rhythm using the Bjorklund algorithm. PULSES is the number of "hits" in the sequence, STEPS is number of divisions of the sequence, and OFFSET is the number to rotate the sequence by. This function returns a list, where 1 represents a note and 0 represents a rest. If you want to use bjorklund in a pattern, you may be more interested in ‘pbjorklund’ instead, which returns events with the correct duration and type.
Example: (bjorklund 3 7) ;=> (1 0 1 0 1 0 0)
See also: ‘pbjorklund’
Get a list of the midi note numbers in the specified chord.
Return a list consisting of the note numbers for CHORD.
Get the degree of CHROMATIC-INDEX.
Get the frequency of CHROMATIC-INDEX.
Get the midinote of CHROMATIC-INDEX.
Get the note of CHROMATIC-INDEX.
Note that this function is not aware of context and thus always returns the first known name of each note, not necessarily the one that is "correct".
A list of conditions caught by the clock while processing tasks when its condition-handler is non-nil. Each entry in the list is a plist containing the the condition and the stack trace.
See also: ‘clock-condition-handler’
The restart to invoke when a condition occurs during task processing. If nil, the clock will not attempt to handle any conditions. If non-nil, all conditions signaled within a task will be caught and the specified restart will be invoked automatically to prevent the clock from pausing. Caught conditions will be printed as a warning and recorded with their stack trace in the clock’s caught-conditions slot.
See also: ‘clock-caught-conditions’
The default latency for events played on the clock; the number of seconds added onto the event’s scheduled time, in order to allow the backend to process it without being "late".
Convenience method for processing a clock’s tasks in a loop.
To run the clock in a new thread, you can call ‘start-clock-loop’.
See also: ‘start-clock-loop’, ‘clock-process’
Process tasks on CLOCK for the next BEATS beats.
See also: ‘clock-loop’, ‘clock-tasks’, ‘make-clock’
Get a list of all tasks running on CLOCK.
See also: ‘pattern-tasks’
Get a new event that inserts all the items in each event of EVENTS. Keys from the events listed first will be overwritten by later events.
See also: ‘copy-event’, ‘split-event-by-lists’, ‘combine-events-via-lists’
Combine EVENTS together to produce one event. Any keys that differ between the events will have be set to lists containing all the values from each event (unless the value is null). This is the opposite of ‘split-event-by-lists’.
Example:
;; (combine-events-via-lists (event :foo 1 :bar 2 :qux 4) (event :foo 1 :bar 3 :baz 5))
;; => (EVENT :FOO 1 :BAR (2 3) :QUX 4 :BAZ 5)
See also: ‘split-event-by-lists’, ‘combine-events’
Get a new event that is a copy of EVENT.
See also: ‘combine-events’
Convert decibels to amplitude.
Define a musical chord.
See also: ‘scale’, ‘define-tuning’, ‘define-scale’
Define a musical scale.
See also: ‘scale’, ‘define-tuning’, ‘define-chord’
Define a musical tuning.
See also: ‘tuning’, ‘define-scale’, ‘define-chord’
Get the chromatic index of DEGREE.
Get the frequency of DEGREE, based on the ROOT, OCTAVE, and SCALE, if provided.
Get the note in SCALE at the index DEGREE, possibly overriding STEPS-PER-OCTAVE.
Get the midi note number of DEGREE, taking into account the ROOT, OCTAVE, and SCALE, if provided.
Get the note number of DEGREE in SCALE.
Get the octave of DEGREE.
Convert DUR in beats to frequency in Hz according to TEMPO in beats per second.
Convert DUR in beats to time in seconds according to TEMPO in beats per second.
Syntax sugar; like ‘event-value’, but always gets the value from ‘*event*’.
See also: ‘event-value’, ‘event’, ‘*event*’
Get a list of all enabled backends.
See also: ‘all-backends’, ‘backend-enabled-p’
Create an eseq containing the specified events and metadata.
Get the number of events in ESEQ.
True if OBJECT is an eseq.
See also: ‘eseq’
Create an event, using the PARAMS as its keys/values.
See also: ‘event-value’, ‘event-p’, ‘e’, ‘*event*’
Test if EVENT-1 and EVENT-2 are equivalent.
See also: ‘every-event-equal’
True if OBJECT is an event.
See also: ‘event’, ‘event-value’
Get the value of KEY in EVENT, running any necessary conversion functions.
Returns 2 values: the value of the key, and the name of the key the value was derived from (or t if the default value of the key was used, or nil if no value or default was provided).
See also: ‘event’, ‘e’, ‘raw-event-value’
Set the value of KEY to VALUE in EVENT, running any conversion functions that exist.
Get a list of keys that differ between EVENTS.
See also: ‘every-event-equal’
Get a list of the keys that differ between respective event in LISTS.
Example:
;; (events-lists-differing-keys (list (event :foo 1 :bar 2) (event :bar 3) (event :foo 1 :bar 3))
;; (list (event :foo 1 :bar 2) (event :foo 1 :bar 3) (event :foo 2 :bar 3)))
;; => (NIL (:FOO) (:FOO))
See also: ‘every-event-equal’
Test if all the events in LISTS are equivalent. Like (every #’event-equal LIST-1 LIST-2 ...) but returns false if the lists are not the same length.
See also: ‘event-equal’, ‘events-differing-keys’
Find a registered backend whose name or type matches BACKEND. With ENABLED-P, only search through currently enabled backends.
See also: ‘all-backends’, ‘enabled-backends’
Get the object named NAME in the pdef dictionary. If ERRORP is true, signals an error when NAME isn’t found in the dictionary. Returns t or nil as a second value showing whether the symbol was found.
See also: ‘pdef-p’, ‘all-pdefs’, ‘all-pdef-names’
Get the chromatic index of FREQ.
Convert a frequency to a scale degree.
Convert FREQ in Hz to duration in beats according to TEMPO in beats per second.
Convert a frequency to a midi note number.
Get the note for the frequency provided.
Get the octave number that the frequency FREQ occurs in.
Convert the frequency FREQ to a playback rate, based on BASE-FREQ. Useful to convert musical pitch information to a number usable for sample playback synths.
Convert FREQUENCY to a MIDI note number (rounding to ensure it’s an integer).
Note that this function is meant for use with the MIDI backend; for frequency-to-midinote conversion without rounding, see ‘freq-midinote’ instead.
Get a mapping from INSTRUMENT (an instrument name as a string or symbol) to a plist of parameters which should be set in the event by ‘remap-instrument-to-parameters’.
See also: ‘remap-instrument-to-parameters’, ‘*instrument-map*’
Set a mapping from INSTRUMENT (an instrument name as a string or symbol) to a plist of parameters which will be set in the event by ‘remap-instrument-to-parameters’. Setting an instrument to nil with this function removes it from the map.
See also: ‘instrument-mapping’, ‘remap-instrument-to-parameters’, ‘*instrument-map*’
Insertable pstream; a pstream that can be changed while it’s running by inserting new patterns at a specified beat.
Load a Scala (.scl) scale file and define a tuning and scale from it.
Note that Scala refers to these as "scales" but in cl-patterns they are known as tunings.
Create a clock with a tempo of TEMPO in beats per second (Hz).
To start the clock so that it begins processing its tasks in a new thread, you can use ‘start-clock-loop’. Alternatively, you can call ‘clock-loop’ yourself to start the loop in the current thread. The clock can also be advanced manually an arbitrary number of beats at a time with the ‘clock-process’ function.
See also: ‘clock-process’, ‘clock-loop’, ‘start-clock-loop’
Convert a MIDI note number difference to a frequency ratio.
Truncate NUMBER and clamp it to the range 0..MAX (default 127).
Get the chromatic index of MIDINOTE.
Get the degree of MIDINOTE, taking into account the ROOT, OCTAVE, and SCALE, if provided.
Convert a midi note number to a frequency.
Get the note name of MIDINOTE.
Get the octave number that MIDINOTE occurs in.
Convert a midinote to a playback rate.
Get a plist of the mouse location, total display size, and other information gleaned about DISPLAY-SERVER. DISPLAY-SERVER can be :x, :wayland, etc, but should default to the correct display server detected when cl-patterns is loaded. Will signal an error if the information cannot be determined (i.e. when the display server is not detected or not supported).
NOTE: This is currently only implemented on X-based systems, so will not work on Windows, MacOS, and Wayland.
Call FUNCTION on the provided arguments. If one or more of the arguments is a list, funcall for each element of the list(s). The length of the resulting list will be the same as the longest input list.
Example:
;; (multi-channel-funcall #’+ 1 (list 1 2 3))
;; => (2 3 4)
See also: ‘mapcar-longest’, ‘split-event-by-lists’
Get the next valid beat for QUANT after BEAT. If DIRECTION is negative, finds the previous valid beat for QUANT.
See also: ‘quant’
Get the next N outputs of a pstream, function, or other object, advancing the pstream forward N times in the process.
See also: ‘next’, ‘next-upto-n’, ‘peek’, ‘peek-n’
Get a list of up to N results from PSTREAM, not including the end of pattern.
See also: ‘next’, ‘next-n’, ‘peek’, ‘peek-upto-n’
Get the chromatic index of NOTE.
Get the degree of a note in the provided scale. If the note is not in the provided scale, truncate to the nearest note that is.
Given a note, return its frequency in hertz, taking into account the ROOT and OCTAVE if provided.
See also: ‘note-midinote’
Given a note, return its midi note number, taking into account the OCTAVE if provided.
See also: ‘note-freq’
Given a note name, return a list consisting of its note number and its octave (defaulting to 4 if it’s not specified).
Examples:
;; (note-name-and-octave :c4) ;=> (:C 4)
;; (note-name-and-octave :a#7) ;=> (:A# 7)
;; (note-name-and-octave :c-1) ;=> (:C -1)
;; (note-name-and-octave :d) ;=> (:D 4)
See also: ‘note-midinote’, ‘chromatic-index-note’
Get the octave of NOTE.
Get the degree of OCTAVE.
Get the base frequency of OCTAVE.
Get the base (lowest) midi note number for OCTAVE.
Get the note of OCTAVE.
Syntax sugar for (pnary #’* ...).
See also: ‘pnary’, ‘common-lisp:*’
Syntax sugar for (pnary #’+ ...).
See also: ‘pnary’, ‘common-lisp:+’
Syntax sugar for (pnary #’- ...).
See also: ‘pnary’, ‘common-lisp:-’
Syntax sugar for (pnary #’/ ...).
See also: ‘pnary’, ‘common-lisp:/’
Syntax sugar for (pnary #’/= ...).
See also: ‘pnary’, ‘common-lisp:/=’
Syntax sugar for (pnary #’< ...).
See also: ‘pnary’, ‘common-lisp:<’
Syntax sugar for (pnary #’<= ...).
See also: ‘pnary’, ‘common-lisp:<=’
Syntax sugar for (pnary #’= ...).
See also: ‘pnary’, ‘common-lisp:=’
Syntax sugar for (pnary #’> ...).
See also: ‘pnary’, ‘common-lisp:>’
Syntax sugar for (pnary #’>= ...).
See also: ‘pnary’, ‘common-lisp:>=’
Numeric accumulator. Each output and STEP is used as the input for OPERATOR to generate the next output. When LO, HI, and BOUND-BY are provided, outputs that fall outside the range LO..HI are wrapped back inside with the BOUND-BY function; the value is provided as its first argument, and LO and HI are provided as its second and third.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-upto-n (paccum #’+ 0 1) 5) ; same as (pseries 0 1)
;; ;=> (0 1 2 3 4)
;; (next-upto-n (paccum #’+ 0 1 :inf :lo 0 :hi 3 :bound-by #’wrap) 9) ; same as above, wrapping between 0 and 3.
;; ;=> (0 1 2 0 1 2 0 1 2)
See also: ‘pseries’, ‘pgeom’, ‘pwalk’
Automatically group outputs of the source pattern into lists of up to N items each. Unlike ‘pclump’, clump size is automatically set to the length of the longest list in the values of ‘*event*’, or 1 if there are no lists.
Example:
;; (next-upto-n (pbind :foo (pseq ’((1) (1 2) (1 2 3)) 1) :bar (paclump (pseries))))
;; ;=> ((EVENT :FOO (1) :BAR (0)) (EVENT :FOO (1 2) :BAR (1 2)) (EVENT :FOO (1 2 3) :BAR (3 4 5)))
See also: ‘pclump’
Arpeggiator pattern; each event yielded by PATTERN is bound to ‘*event*’ and then the entirety of the ARPEGGIATOR pattern is yielded.
Example:
;; (next-upto-n (parp (pbind :foo (pseq ’(1 2 3) 1))
;; (pbind :bar (pseq ’(4 5 6) 1))))
;; ;=> ((EVENT :FOO 1 :BAR 4) (EVENT :FOO 1 :BAR 5) (EVENT :FOO 1 :BAR 6)
;; (EVENT :FOO 2 :BAR 4) (EVENT :FOO 2 :BAR 5) (EVENT :FOO 2 :BAR 6)
;; (EVENT :FOO 3 :BAR 4) (EVENT :FOO 3 :BAR 5) (EVENT :FOO 3 :BAR 6))
See also: ‘psym’, ‘pmeta’, ‘pr’
Like ‘as-pstream’, but only converts THING to a pstream if it is a pattern.
Get a list of all the direct child patterns of PATTERN, including any in slots or lists.
See also: ‘pattern-parent’
True if OBJECT is a pattern.
See also: ‘pattern’, ‘defpattern’
Get the NUM-th containing pattern of PATTERN, or nil if there isn’t one. If CLASS is specified, only consider patterns of that class.
See also: ‘pattern-children’
Attempt to get the tasks on CLOCK that are playing PATTERN.
See also: ‘task-pattern’, ‘clock-tasks’
Yield the number of beats elapsed since the pbeat was embedded in the pstream.
Example:
;; (next-n (pbind :dur (pseq ’(1 2 3)) :foo (pbeat)) 3)
;; ;=> ((EVENT :DUR 1 :FOO 0) (EVENT :DUR 2 :FOO 1) (EVENT :DUR 3 :FOO 3))
See also: ‘pbeat*’, ‘beat’, ‘prun’
Yield the number of beats on the ‘*clock*’ of the current pattern. In other words, pbeat* is clock-synced, unlike ‘pbeat’, which is pattern-synced.
Example:
;; (next-n (pbind :dur (pseq ’(1 2 3)) :foo (pbeat*)) 3)
;; ;=> ((EVENT :DUR 1 :FOO 200) (EVENT :DUR 2 :FOO 201) (EVENT :DUR 3 :FOO 203))
See also: ‘pbeat’, ‘beat’, ‘prun’
pbind yields events determined by its PAIRS, which are a list of keys and values. Each key corresponds to a key in the resulting events, and each value is treated as a pattern that is evaluated for each step of the pattern to generate the value for its key.
Example:
;; (next-n (pbind :foo (pseq ’(1 2 3)) :bar :hello) 4)
;;
;; ;=> ((EVENT :FOO 1 :BAR :HELLO) (EVENT :FOO 2 :BAR :HELLO) (EVENT :FOO 3 :BAR :HELLO) EOP)
See also: ‘pmono’, ‘pb’
pbjorklund generates Euclidean rhythms using the Bjorklund algorithm. PULSES is the number of notes in the sequence, and STEPS is number of steps in the sequence. Additionally, OFFSET is the number to rotate the sequence by, DUR is the total duration one repeat of the sequence should be, and REPEATS is the number of repeats that should be yielded. This pattern outputs events which can be embedded into another pattern. Each pulse is a note, and each subdivision of the sequence that is not a pulse is a rest. If you just want the raw output from the Bjorklund algorithm (not in pattern form), use ‘bjorklund’ instead.
Example:
;; (next-upto-n (pbjorklund 3 7))
;; => ((EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7))
See also: ‘bjorklund’
Brownian motion within a range; each output randomly a maximum of STEP away from the previous. LO and HI define the lower and upper bounds of the range. STEP defaults to 1 if LO and HI are integers.
Example:
;; (next-upto-n (pbrown 0 10 1 10))
;; ;=> (2 3 3 3 4 3 4 5 6 5)
See also: ‘pwhite’, ‘pexprand’, ‘pgauss’
Combine multiple patterns into one event stream.
Example:
;; (next-n (pchain (pbind :foo (pseq ’(1 2 3))) (pbind :bar (pseq ’(7 8 9) 1))) 4)
;;
;; ;=> ((EVENT :FOO 1 :BAR 7) (EVENT :FOO 2 :BAR 8) (EVENT :FOO 3 :BAR 9) NIL)
See also: ‘pbind”s :embed key
Group outputs of the source pattern into lists of up to N items each.
Example:
;; (next-upto-n (pclump (pseries 0 1 5) 2))
;; ;=> ((0 1) (2 3) (4))
See also: ‘paclump’
pcycles yields values from LIST as events whose dur is (/ 1 list-length) and whose value is the original value in the list. This process recurses into sublists, subdividing their durs equally among the sublist’s contents to be a fraction of what their dur originally would be. The total dur yielded by pcycles is always equal to 1. pcycles repeats the whole LIST once.
Define a named pattern, with NAME being the name of the pattern and PATTERN the pattern itself. Named patterns are stored in a global dictionary and can be referred back to by calling ‘pdef’ without supplying PATTERN. The global dictionary also keeps track of the pdef’s pstream when ‘play’ is called on it. If a pdef is redefined while it is being played, the changes won’t be audible until either PATTERN ends, or the pdef’s ‘end-quant’ time is reached (if non-nil). Note that, unlike bare patterns, pdefs loop by default when played (‘loop-p’).
Example:
;; (pdef :foo (pbind :degree (pseries 0 1 4)))
;;
;; (play (pdef :foo))
;; ;; redefine the pdef’s pattern... note that the redefinition doesn’t become audible until the current loop finishes playing:
;; (pdef :foo (pbind :degree (pseries 4 -1 4)))
See also: ‘find-pdef’, ‘all-pdefs’, ‘pb’, ‘pmeta’, ‘ps’
Test whether OBJECT is a pdef.
See also: ‘find-pdef’
Output the difference between successive outputs of PATTERN, assuming PATTERN restarts every CYCLE outputs.
Unlike ‘pdiff’, pdelta is written with its use as input for ‘pbind”s :delta key in mind. If PATTERN’s successive values would result in a negative difference, pdelta instead wraps the delta around to the next multiple of CYCLE. This would allow you to, for example, supply the number of the beat that each event occurs on, rather than specifying the delta between each event. This is of course achievable using pbind’s :beat key as well, however that method requires the pbind to peek at future values, which is not always desirable.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-n (pdelta (pseq ’(0 1 2 3)) 4) 8)
;;
;; ;=> (1 1 1 1 1 1 1 1)
;;
;; (next-n (pdelta (pseq ’(0 1 2 5)) 4) 8)
;;
;; ;=> (1 1 3 3 1 1 3 3)
See also: ‘pdiff’, ‘pbind”s :beat key
Output the difference between successive outputs of PATTERN.
Example:
;; (next-n (pdiff (pseq ’(3 1 4 3) 1)) 4)
;;
;; ;=> (-2 3 -1 NIL)
See also: ‘pdelta’
Drop the first N outputs from PATTERN and yield the rest. If N is negative, drop the last N outputs from PATTERN instead.
Example:
;; (next-n (pdrop (pseq ’(1 2 3 4) 1) 2) 4)
;;
;; ;=> (3 4 NIL NIL)
See also: ‘protate’
Yield each output from PATTERN N times, dividing it by N. If the output from PATTERN is an event, its dur is divided; if it’s a number, the number itself is divided instead of being yielded directly.
Example:
;; (next-n (pdurstutter (pseq ’(1 2 3 4 5)) (pseq ’(3 2 1 0 2))) 9)
;; ;=> (1/3 1/3 1/3 1 1 3 5/2 5/2 NIL)
;;
;; (next-n (pdurstutter (pbind :dur (pseq ’(1 2 3 4 5)))
;; (pseq ’(3 2 1 0 2)))
;; 9)
;; ;=> ((EVENT :DUR 1/3) (EVENT :DUR 1/3) (EVENT :DUR 1/3) (EVENT :DUR 1) (EVENT :DUR 1) (EVENT :DUR 3) (EVENT :DUR 5/2) (EVENT :DUR 5/2) NIL)
See also: ‘pr’
Peek at the next N results of a pstream, without advancing it forward in the process.
See also: ‘peek’, ‘peek-upto-n’, ‘next’, ‘next-n’
Peek at up to the next N results of a pstream, without advancing it forward in the process.
See also: ‘peek’, ‘peek-n’, ‘next’, ‘next-upto-n’
Syntax sugar for (pnary #’eql ...).
See also: ‘pnary’, ‘common-lisp:eql’
Exponentially-distributed random numbers between LO and HI. Note that LO and HI cannot be 0, and that LO and HI must have the same sign or else complex numbers will be output.
Example:
;; (next-upto-n (pexprand 1.0 8.0 4))
;; ;=> (1.0420843091865208d0 1.9340168112124456d0 2.173209129035095d0 4.501371557329618d0)
See also: ‘pwhite’, ‘pbrown’, ‘pgauss’, ‘prand’
Skip elements of a source pattern that PREDICATE returns false for. If PREDICATE is not a function, skip items that are ‘eql’ to it.
Example:
;; (next-n (pfilter (pseq (list 1 2 3))
;; 2)
;; 6)
;; ;=> (1 3 1 3 1 3)
;; (next-n (pfilter (pseries 0 1) ’evenp)
;; 6)
;; ;=> (1 3 5 7 9 11)
See also: ‘pfilter-out’, ‘pr’, ‘pdurstutter’
Skip elements of a source pattern that PREDICATE returns true for. If PREDICATE is not a function, skip items that are ‘eql’ to it.
See also: ‘pfilter’
Yield up to COUNT outputs from PATTERN.
Example:
;; (next-n (pfin (pseq ’(1 2 3) :inf) 3) 5)
;; ;=> (1 2 3 NIL NIL)
See also: ‘pfindur’
Yield events from PATTERN until their total duration is within TOLERANCE of DUR, or greater than DUR. Any events that would end beyond DUR are cut short. If PATTERN outputs numbers, their total sum is limited instead.
Example:
;; (next-n (pfindur (pbind :dur 1 :foo (pseries)) 2) 3)
;; ;=> ((EVENT :DUR 1 :FOO 0) (EVENT :DUR 1 :FOO 1) EOP)
;;
;; (next-upto-n (pfindur (pwhite 0 4) 16))
;; ;=> (1 3 0 1 2 2 1 3 0 1 2)
;; (reduce #’+ *)
;; ;=> 16
See also: ‘pfin’, ‘psync’
Yield the result of evaluating FUNC. Note that the current event of the parent pattern is still accessible via the ‘*event*’ special variable.
Example:
;; (next-upto-n (pfunc (lambda () (random 10)) 4))
;; ;=> ((5 2 8 9))
;;
;; (next-upto-n (pbind :foo (pwhite 0 10 4)
;; :bar (pfunc (lambda ()
;; (if (> (event-value *event* :foo) 5) :greater :lesser)))))
;; ;=> ((EVENT :FOO 0 :BAR :LESSER) (EVENT :FOO 6 :BAR :GREATER)
;; (EVENT :FOO 7 :BAR :GREATER) (EVENT :FOO 8 :BAR :GREATER))
See also: ‘pf’, ‘pnary’, ‘plazy’, ‘pif’
Random numbers distributed along a normal (gaussian) curve. MEAN is the "center" of the distribution, DEVIATION is the standard deviation (i.e. the higher the value, the further the outputs are spread from MEAN).
Example:
;; (next-n (pgauss) 4)
;; ;=> (0.08918811646370092d0 0.1745957067161632d0 0.7954678768273173d0 -1.2215823449671597d0)
See also: ‘pwhite’, ‘pexprand’, ‘pbrown’
Yield START, then generate subsequent outputs by multiplying by GROW, for a total of LENGTH outputs.
Example:
;; (next-upto-n (pgeom 1 2 4))
;; ;=> (1 2 4 8)
See also: ‘pseries’, ‘paccum’
Syntax sugar to generate a ‘pgeom’ whose values go from START to END exponentially over LENGTH steps. LENGTH cannot be infinite since delta calculation requires dividing by it.
Based on the Pgeom extension from the ddwPatterns SuperCollider library.
Example:
;; (pgeom* 1 100 8)
;; ;=> (pgeom 1 1.9306977 8)
;;
;; (next-upto-n *)
;; ;=> (1 1.9306977 3.7275934 7.196856 13.894953 26.826954 51.79474 99.999985)
;; ;; Note that due to floating point rounding errors the last output may not always be exactly END.
See also: ‘pgeom’, ‘pseries’, ‘pseries*’
Refer back to PATTERN’s history, yielding the output at the index provided by STEP-PATTERN.
Note that PATTERN is still advanced once per event, and if STEP-PATTERN yields a number pointing to an event in PATTERN that hasn’t been yielded yet (i.e. if PATTERN has only advanced once but STEP-PATTERN yields 3 for its output), phistory yields nil.
Example:
;; (next-n (phistory (pseries) (pseq ’(0 2 1))) 3)
;; ;=> (0 NIL 1)
See also: ‘pscratch’
"If" expression for patterns. TEST is evaluated for each step, and if it’s non-nil, the value of TRUE will be yielded, otherwise the value of FALSE will be. Note that TRUE and FALSE can be patterns, and if they are, they are only advanced in their respective cases, not for every step.
Example:
;; (next-n (pif (pseq ’(t t nil nil nil)) (pseq ’(1 2 3)) (pseq ’(9 8 7))) 8)
;; ;=> (1 2 9 8 7 3 1 9)
See also: ‘plazy’, ‘pfunc’
Use INDEX-PAT to index into the list returned by LIST-PAT. WRAP-P is whether indexes that are out of range will be wrapped (if t) or will simply return nil.
Example:
;; (next-n (pindex (list 99 98 97) (pseq (list 0 1 2 3))) 4)
;;
;; ;=> (99 98 97 NIL)
;;
;; (next-upto-n (pindex (list 99 98 97) (pseries 0 1 6) t))
;;
;; ;=> (99 98 97 99 98 97)
See also: ‘pwalk’
Yield the value of KEY in the current ‘*event*’ context, returning DEFAULT if that value is nil.
Example:
;; (next-upto-n (pbind :foo (pseq ’(1 2 3) 1) :bar (pk :foo)))
;; ;=> ((EVENT :FOO 1 :BAR 1) (EVENT :FOO 2 :BAR 2) (EVENT :FOO 3 :BAR 3))
See also: ‘pbind’, ‘event-value’, ‘*event*’
Yield each value from LIST in sequence. If the value is a list, the first element of that list is yielded. The second time that sub-list is encountered, its second element will be yielded; the third time, the third element, and so on. REPEATS controls the number of times LIST is repeated.
Example:
;; (next-upto-n (place (list 1 2 (list 3 4 5)) 3))
;; ;=> (1 2 3 1 2 4 1 2 5)
See also: ‘ppatlace’
‘play’ an object, or ‘end’ it if it’s already playing. Returns the task if the object will start playing, or NIL if it will end.
‘play’ an object, or ‘stop’ it if it is already playing. Returns the task if the object will start playing, or NIL if it will stop.
End or stop all tasks on CLOCK and play OBJECT (or simply let it continue playing if it’s already playing).
See also: ‘play’, ‘end’, ‘stop’, ‘play-swap’
Play PLAY, and end (or stop) END.
See also: ‘play’, ‘end’, ‘stop’, ‘play-solo’
Get a list of all nodes on BACKEND that are currently playing. Without BACKEND, get all playing nodes on all backends.
See also: ‘all-instruments’, ‘playing-pdefs’, ‘playing-p’
Get a list of the names of all pdefs playing on CLOCK.
See also: ‘playing-pdefs’, ‘all-pdefs’, ‘playing-nodes’, ‘playing-p’
Get a list of the names of all pdefs playing on CLOCK.
See also: ‘playing-pdef-names’, ‘all-pdefs’, ‘playing-nodes’, ‘playing-p’
Evaluates FUNC to generate a pattern, which is then yielded from until its end, at which point FUNC is evaluated again to generate the next pattern. The pattern is generated a total of REPEATS times.
Example:
;; (next-n (plazy (lambda () (if (= 0 (random 2)) (pseq ’(1 2 3) 1) (pseq ’(9 8 7) 1)))) 6)
;; ;=> (9 8 7 1 2 3)
See also: ‘pfunc’
Meta-control patterns using the events output by PATTERN. In other words, instead of triggering synths directly, the events output by PATTERN are used to embed patterns into the pmeta’s pstream.
The following keys are supported:
- :pattern or :instrument - name of the source pattern for this "step".
- :dur - set the duration of the embedded pattern (defaults to :inf, which causes the pattern to play to its end).
- :findur - limit the duration of the embedded pattern.
- :sync - sync the duration of the embedded pattern to a multiple of the provided value, similar to ‘psync’
- :stretch - multiply the duration of each of the source pattern’s events.
- :ts or :fit - timestretch a pattern so its total duration is the number specified, a la ‘pts’.
- :r or :repeat - repeat each event the number of times returned by the function when the event is applied to it, similar to ‘pr’.
- :inject - inject key/value pairs from the output of this value into the source pattern.
- :step-inject or :sinject - inject one output from this value per step.
The following keys are planned for future implementation:
- :start or :end - adjust the start or end points of the source pattern (i.e. to skip the first half, set :start to 0.5).
- :start-beat or :end-beat - adjust the start or end points of the source pattern in number of beats (i.e. to end the pattern 2 beats early, set :end-beat to -2).
- :start-nth or :end-nth - adjust the start or end points of the source pattern by skipping the first or last N events.
- :filter or :remove-if-not - skip all events from the source pattern that return nil when applied to the specified function or pattern.
- :mapcar or :nary - process each event from the source pattern with a function or another pattern.
See doc/special-keys.org for more information on these keys.
Example:
;; ;; define a few patterns...
;; (pdef :foo (pbind :x (pseq ’(1 2 3) 1) :dur 1))
;; (pdef :bar (pbind :y (pseries) :dur (pwhite 0.1 1.0 3)))
;;
;; ;; use pmeta to play pattern foo and then pattern bar, ensuring each are 2 beats long in total by way of pmeta’s sync key, which works similarly to ‘psync’
;; (next-upto-n (pmeta :pattern (pseq (list :foo :bar) 1) :sync 2))
;; ;=> ((EVENT :X 1 :DUR 1) (EVENT :X 2 :DUR 1) ; from (pdef :foo)
;; (EVENT :Y 0 :DUR 0.76958686) (EVENT :Y 1 :DUR 0.94850993) (EVENT :Y 2 :DUR 0.28190327)) ; from (pdef :bar)
See also: ‘psym’, ‘parp’, ‘pdef’, ‘pbind’
pmono defines a mono instrument event pstream. It’s effectively the same as ‘pbind’ with its :type key set to :mono.
See also: ‘pbind’
Get the mouse position of the display server (GUI). ORIENTATION can be :x or :y, and FORMAT can be either :relative (in which case the output is a number from 0 to 1 as a fraction of total display size) or :absolute (in which case the output is the actual X or Y position of the mouse).
See also: ‘pmousex’, ‘pmousey’, ‘mouse-location’
Get the mouse’s x position on screen. FORMAT can be either :relative (in which case the output is a number from 0 to 1 as a fraction of total display size) or :absolute (in which case the output is the actual X or Y position of the mouse).
See also: ‘pmouse’, ‘pmousey’, ‘mouse-location’
Get the mouse’s y position on screen. FORMAT can be either :relative (in which case the output is a number from 0 to 1 as a fraction of total display size) or :absolute (in which case the output is the actual X or Y position of the mouse).
See also: ‘pmouse’, ‘pmousex’, ‘mouse-location’
Embed the full PATTERN into the pstream REPEATS times.
Example:
;; (next-upto-n (pn (pwhite 0 5 1) 5))
;; ;=> (2 4 2 1 0)
See also: ‘pr’
Yield the result of applying OPERATOR to each value yielded by each pattern in PATTERNS.
Example:
;; (next-upto-n (pnary (pseq (list ’+ ’- ’* ’/) 2) 2 2))
;; ;=> (4 0 4 1)
See also: ‘pfunc’, ‘p+’, ‘p-’, ‘p*’, ‘p/’
Combine multiple event patterns into one pstream with all events in temporal order. PATTERNS is the list of patterns, or a pattern yielding lists of patterns. The ppar ends when all of the patterns in PATTERNS end.
Example:
;; (next-upto-n (ppar (list (pbind :dur (pn 1/2 4))
;; (pbind :dur (pn 2/3 4)))))
;;
;; ;=> ((EVENT :DUR 1/2 :DELTA 0) (EVENT :DUR 2/3 :DELTA 1/2)
;; (EVENT :DUR 1/2 :DELTA 1/6) (EVENT :DUR 2/3 :DELTA 1/3)
;; (EVENT :DUR 1/2 :DELTA 1/3) (EVENT :DUR 2/3 :DELTA 1/6)
;; (EVENT :DUR 1/2 :DELTA 1/2) (EVENT :DUR 2/3 :DELTA 2/3))
See also: ‘psym’
Combine multiple patterns into several event streams. The event yielded by the first pattern will be used as the input event to the second pattern, and so on. The events yielded by each pattern will be collected into a list and yielded by the pparchain. This pattern is effectively ‘ppar’ and ‘pchain’ combined.
Example:
;; (next-upto-n (pparchain (pbind :foo (pseries 0 1 3)) (pbind :baz (p+ (pk :foo) 1) :foo (p+ (pk :foo) 3))))
;; ;=> (((EVENT :FOO 0) (EVENT :FOO 3 :BAZ 1))
;; ((EVENT :FOO 1) (EVENT :FOO 4 :BAZ 2))
;; ((EVENT :FOO 2) (EVENT :FOO 5 :BAZ 3)))
See also: ‘ppc’, ‘ppar’, ‘pchain’, ‘pbind”s :embed key
Yield each value from LIST in sequence, or one output from each pattern in LIST per cycle of the list. If one of the patterns embedded in LIST ends sooner than the others, it is simply removed and the ppatlace continues to yield from the rest of the LIST. The entire LIST is yielded through a total of REPEATS times.
Example:
;; (next-upto-n (ppatlace (list (pseq (list 1 2 3) 1)
;; (pseq (list 4 5 6) 2))))
;; ;=> (1 4 2 5 3 6 4 5 6)
See also: ‘place’
Repeat each value from PATTERN REPEATS times. If REPEATS is 0, the value is skipped.
Example:
;; (next-upto-n (pr (pseries) (pseq ’(1 3 0 2) 1)))
;; ;=> (0 1 1 1 3 3)
See also: ‘pdurstutter’, ‘pn’, ‘pdrop’, ‘parp’
Yield random values from LIST.
Example:
;; (next-n (prand ’(1 2 3) 5) 6)
;; ;=> (3 2 2 1 1 EOP)
See also: ‘pxrand’, ‘pwrand’, ‘pwxrand’
Remap INPUT from one range, specified by FROM-RANGE, to another range, specified by TO-RANGE.
Note that this is effectively a convenience wrapper over ‘pnary’ and ‘rerange’; thus you should see ‘rerange’ for more information.
See also: ‘rerange’, ‘pnary’
Make a prest object, which, when used in a ‘pbind’ or similar event pattern, turns the current event into a rest and yields VALUE for the key’s value.
Note that this is not a pattern; it is just a regular function that returns a prest object.
Example:
;; (next-upto-n (pbind :degree (pseq (list 0 1 (prest 2) 3) 1)))
;; ;=> ((EVENT :DEGREE 0) (EVENT :DEGREE 1) (EVENT :TYPE :REST :DEGREE 2) (EVENT :DEGREE 3))
See also: ‘pbind’, ‘pbind”s :type key
Rotate PATTERN N outputs forward or backward, wrapping the shifted items to the other side, a la ‘alexandria:rotate’.
Example:
;; (next-upto-n (protate (pseq ’(1 2 3 4 5) 1) 2))
;; ;=> (4 5 1 2 3)
See also: ‘pdrop’, ‘phistory’, ‘pscratch’
Syntax sugar for (pr (ps PATTERN) REPEATS). Useful, for example, to ensure that each loop of a pattern only gets one value from the ‘ps’.
See also: ‘pr’, ‘ps’
Run PATTERN "independently" of its parent, holding each value for DUR beats. Each of PATTERN’s outputs is treated as if it lasted DUR beats, being continuously yielded during that time before moving on to the next output.
Example:
;; (next-upto-n (pbind :foo (pseq ’(1 2 3 4 5))
;; :bar (prun (pseq ’(4 5 6 7 8))
;; (pseq ’(1 2 0.5 0.5 1)))))
;; ;=> ((EVENT :FOO 1 :BAR 4)
;; (EVENT :FOO 2 :BAR 5)
;; (EVENT :FOO 3 :BAR 5)
;; (EVENT :FOO 4 :BAR 6)
;; (EVENT :FOO 5 :BAR 8))
See also: ‘beat’, ‘pbeat’
Preserve pstream state across subsequent calls to ‘as-pstream’. To reset the pstream, simply re-evaluate the ps definition.
Based on the pattern originally from the miSCellaneous SuperCollider library.
Example:
;; (defparameter *pst* (ps (pseries)))
;;
;; (next-upto-n *pst* 4)
;; ;=> (0 1 2 3)
;;
;; (next-upto-n *pst* 4)
;; ;=> (4 5 6 7)
;;
;; (defparameter *pst* (ps (pseries)))
;;
;; (next-upto-n *pst* 4)
;; ;=> (0 1 2 3)
See also: ‘prs’, ‘pdef’
"Scratches" across the values yielded by a pstream, similar in concept to how a DJ might scratch a record, altering the normal flow of playback. PATTERN is the source pattern, and STEP-PATTERN determines the increment of the index into the pstream history.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-upto-n (pscratch (pseries) (pseq ’(0 1 1 -1 2) 2)))
;; ;=> (0 0 1 2 1 3 3 4 5 4)
See also: ‘phistory’
Sequentially yield items from LIST, repeating the whole list REPEATS times. OFFSET is the offset to index into the list.
Example:
;; (next-n (pseq ’(5 6 7) 2) 7)
;; ;=> (5 6 7 5 6 7 EOP)
;;
;; (next-upto-n (pseq ’(5 6 7) 2 1))
;; ;=> (6 7 5 6 7 5)
See also: ‘pser’, ‘eseq’
Sequentially yield values from LIST, yielding a total of LENGTH values.
Example:
;; (next-n (pser ’(5 6 7) 2) 3)
;;
;; ;=> (5 6 EOP)
See also: ‘pseq’
Yield START, then generate subsequent outputs by adding STEP, for a total of LENGTH outputs.
Example:
;; (next-upto-n (pseries 1 2 4))
;; ;=> (1 3 5 7)
See also: ‘pseries*’, ‘pgeom’, ‘paccum’
Syntax sugar to generate a ‘pseries’ whose values go from START to END linearly over LENGTH steps. If LENGTH is not provided, it is calculated such that the step will be 1. Note that LENGTH cannot be infinite since delta calculation requires dividing by it.
Based on the Pseries extension from the ddwPatterns SuperCollider library.
Example:
;; (pseries* 0 10 16)
;; ;=> (pseries 0 2/3 16)
;;
;; (next-upto-n *)
;; ;=> (0 2/3 4/3 2 8/3 10/3 4 14/3 16/3 6 20/3 22/3 8 26/3 28/3 10)
See also: ‘pseries’, ‘pgeom’, ‘pgeom*’
Shuffle LIST, then yield each item from the shuffled list, repeating it REPEATS times.
Example:
;; (next-upto-n (pshuf ’(1 2 3) 2))
;;
;; ;=> (3 1 2 3 1 2)
See also: ‘prand’
"Slide" across sections of LIST. REPEATS is the total number of sections to output, LEN the length of the section. STEP is the number to increment the start index by after each section, and START is the initial index into LIST that the first section starts from. WRAP-AT-END, when true, means that an index outside of the list will wrap around. When false, indexes outside of the list result in nil.
Example:
;; (next-upto-n (pslide (list 0 1 2 3 4 5 6) 3 3 2 1 t))
;; ;=> (1 2 3 3 4 5 5 6 0)
See also: ‘pscratch’
Get the Nth item in PSTREAM’s history. For negative N, get the -Nth most recent item.
Example:
;; (let ((pstream (as-pstream (pseq ’(1 2 3)))))
;; (next pstream) ;=> 1
;; (pstream-elt pstream 0) ;=> 1 ; first item in the pstream’s history
;; (next pstream) ;=> 2
;; (pstream-elt pstream 1) ;=> 2 ; second item in the pstream’s history
;; (pstream-elt pstream -1)) ;=> 2 ; most recent item in the pstream’s history
See also: ‘pstream-elt-future’, ‘phistory’
Get the element N away from the most recent in PSTREAM’s history. Unlike ‘pstream-elt’, this function will automatically peek into the future for any positive N.
Example:
;; (let ((pstream (as-pstream (pseq ’(1 2 3)))))
;; (pstream-elt-future pstream 0) ;=> 1
;; (next pstream) ;=> 1
;; (pstream-elt-future pstream 1) ;=> 2
;; (next pstream)) ;=> 2
See also: ‘pstream-elt’, ‘phistory’
True if OBJECT is a pstream.
See also: ‘pstream’, ‘as-pstream’
Use a pattern of symbols to embed ‘pdef’s. PATTERN is the source pattern that yields symbols naming the pdef to embed.
Example:
;; (pdef :foo (pseq ’(1 2 3) 1))
;;
;; (pdef :bar (pseq ’(4 5 6) 1))
;;
;; (next-upto-n (psym (pseq ’(:foo :bar) 1)))
;;
;; ;=> (1 2 3 4 5 6)
See also: ‘pdef’, ‘ppar’, ‘pmeta’
Yield events from PATTERN until their total duration is within TOLERANCE of MAXDUR, cutting off any events that would extend past MAXDUR. If PATTERN ends before MAXDUR, a rest is added to the pstream to round its duration up to the nearest multiple of SYNC-QUANT.
Example:
;; (next-upto-n (psync (pbind :dur (pseq ’(5) 1)) 4 16))
;;
;; ;=> ((EVENT :DUR 5) (EVENT :TYPE :REST :DUR 3))
;;
;; (next-upto-n (psync (pbind :dur (pseq ’(5) 5)) 4 16))
;;
;; ;=> ((EVENT :DUR 5) (EVENT :DUR 5) (EVENT :DUR 5) (EVENT :DUR 5 :DELTA 1))
See also: ‘pfindur’
Yield the number of seconds elapsed since ptime was embedded in the pstream.
Note: May give inaccurate results if the clock’s tempo changes occur more frequently than events in the parent pbind.
Example:
;; (setf (tempo *clock*) 1) ; 60 BPM
;; (next-n (pbind :dur 1 :time (ptime)) 2)
;; ;=> ((EVENT :DUR 1 :TIME 0) (EVENT :DUR 1 :TIME 1.0))
See also: ‘pbeat’, ‘prun’, ‘beat’
Print the PREFIX and each output of TRACE to STREAM. If TRACE is t, print ‘*event*’. If TRACE is a different symbol, print the value of that symbol in ‘*event*’. If TRACE is a pattern, ptrace yields its output unaffected. Otherwise, it yields t.
See also: ‘debug-backend’, ‘debug-backend-recent-events’
Defines an event pattern via a tracker-inspired notation. HEADER is a plist mapping the pattern’s "columns" (keys) to their default values or to patterns that are used to generate the key’s values for each output. ROWS is a list of lists, each sublist specifying the values for a step. Values can be specified on their own (in which case they’re matched in order to the columns specified in the header) or by using Lisp’s traditional key/value notation.
By default, the pattern repeats infinitely, however it can be limited by providing a :repeats argument in the header specifying the number of repeats.
Example:
;; (ptrack (list :freq 440 :dur 1/4)
;; ’((100) ; play a note with a frequency of 100
;; :r ; rest for 1/4 beat
;; (:midinote 70 :dur 1/2) ; play a note at midinote 70 for 1/2 beat
;; (-) ; continue previous note for an additional 1/4 beat
;; (600 3/4) ; play a note with a frequency of 600 for 3/4 beat
;; :r ; rest for 1/4 beat
;; (750 :foo 3) ; play a note at frequency 750, dur 1/4, and additional :foo key with value 3
;; ))
See also: ‘pt’, ‘pcycles’, ‘pbind’
Timestretch PATTERN so its total duration is DUR. Note that only the first ‘*max-pattern-yield-length*’ events from PATTERN are considered, and that they are calculated immediately at pstream creation time rather than lazily as the pstream yields.
Example:
;; (next-upto-n (pts (pbind :dur (pn 1 4)) 5))
;;
;; ;=> ((EVENT :DUR 5/4) (EVENT :DUR 5/4) (EVENT :DUR 5/4) (EVENT :DUR 5/4))
See also: ‘pfindur’, ‘psync’
"Walk" over the values in LIST by using the accumulated value of the outputs of STEP-PATTERN as the index. At the beginning of the pwalk and each time the start or end of the list is passed, the output of DIRECTION-PATTERN is taken and used as the multiplier for values from STEP-PATTERN. START-POS is the index in LIST for pwalk to take its first output from.
Example:
;; ;; using (pseq (list 1 -1)) as the DIRECTION-PATTERN causes the pwalk’s output to "ping-pong":
;; (next-n (pwalk (list 0 1 2 3) (pseq (list 1)) (pseq (list 1 -1))) 10)
;;
;; ;=> (0 1 2 3 2 1 0 1 2 3)
See also: ‘pindex’, ‘pbrown’, ‘paccum’
Linearly-distributed random numbers between LO and HI, inclusive.
Example:
;; (next-upto-n (pwhite 0 10 16))
;; ;=> (7 2 4 5 7 10 4 8 10 2 3 5 9 2 5 4)
See also: ‘pexprand’, ‘pbrown’, ‘pgauss’, ‘prand’
Yield random elements from LIST weighted by respective values from WEIGHTS.
Example:
;; (next-upto-n (pwrand ’(1 2 3) ’(7 5 3) 10))
;; ;=> (1 1 2 2 2 1 2 1 1 3)
See also: ‘prand’, ‘pxrand’, ‘pwxrand’
Syntax sugar for (pnary #’wrap ...).
See also: ‘pnary’, ‘mutility:wrap’
Yield random elements from LIST weighted by respective values from WEIGHTS, never repeating equivalent values twice in a row. This is effectively ‘pxrand’ and ‘pwrand’ combined.
Example:
;; (next-upto-n (pwxrand ’(1 2 3) ’(7 5 3) 10))
;; ;=> (1 2 1 2 1 3 1 2 1 2)
See also: ‘prand’, ‘pxrand’, ‘pwrand’
Yield random values from LIST, never repeating equal values twice in a row.
Example:
;; (next-upto-n (pxrand ’(1 2 3) 4))
;; ;=> (3 1 2 1)
See also: ‘prand’, ‘pwrand’, ‘pwxrand’
Return a new list whose elements have been reordered via one of 10 "counting" algorithms. This is based on and tested against SuperCollider’s Array.pyramid method.
Convert a playback rate RATE to a frequency, based on BASE-FREQ.
Convert a playback rate to a midinote.
Convert a frequency ratio to a difference in MIDI note numbers.
Removes KEY from EVENT.
Remap INPUT from one range, specified by FROM-RANGE, to another range, specified by TO-RANGE.
Example:
;; (rerange 64 (list 0 127) (list 0 1)) ; map from [0..127] to [0..1]
;; => 0.503937
See also: ‘to-range’, ‘from-range’, ‘prerange’
Given a scale, return its midi note numbers. OCTAVE can be a number, a 2-element list denoting an octave range, or :all, for the full octave range (0-9).
Get the total dimensions of all monitors known by DISPLAY-SERVER.
Split an event up by any lists in its values. Also known as multichannel expansion.
Example:
;; (split-event-by-lists (event :foo 1 :bar (list 1 2) :baz (list 3 4 5)))
;;
;; => ((EVENT :FOO 1 :BAR 1 :BAZ 3)
;; (EVENT :FOO 1 :BAR 2 :BAZ 4)
;; (EVENT :FOO 1 :BAR 1 :BAZ 5))
See also: ‘multi-channel-funcall’, ‘combine-events-via-lists’, ‘combine-events’
Convenience method to make a clock and start its loop in a new thread if one isn’t already started.
With FORCE, make a new clock and thread even if one already appears to be running.
See also: ‘clock-loop’, ‘*clock*’
Make a t-pstream object with the value VALUE.
True if OBJECT is a ‘t-pstream’.
See also: ‘t-pstream’, ‘as-pstream’
Attempt to get the pattern that TASK is playing. Returns nil if the pattern couldn’t be found.
See also: ‘pattern-tasks’, ‘clock-tasks’
Convert TIME in seconds to duration in beats according to TEMPO in beats per second.
Generate a tone matrix from TONES. Supports symbols t and e for 10 and 11, respectively, but only returns numbers. TRANSFORMATION can be :inversion, :retrograde, or :retrograde-inversion (or a 3-letter abbreviation of any of the above).
Transpose FREQ the specified number of SEMITONES and OCTAVES.
Convert the range 0..1 to 0..127.
Convert a bipolar number (-1 to 1) to a unipolar number (0 to 1).
See also: ‘bipolar-unipolar’
Volume in amplitude, from 0 to 1.
Convert OBJECT to an ‘eseq’.
See also: ‘as-pstream’
Return THING as a pstream object.
See also: ‘pattern-as-pstream’
pbjorklund)) ¶pdurstutter)) ¶pbind-pstream)) ¶Start BACKEND’s server so it is ready to receive events. If BACKEND is the name of a backend rather than a ‘backend’ instance, first make an instance of the backend as if ‘make-backend’ was called, then call ‘backend-start’ on that.
See also: ‘backend-stop’, ‘backend-enabled-p’, ‘make-backend’
symbol) &rest args &key &allow-other-keys) ¶Stop BACKEND’s server if it is running.
See also: ‘backend-start’, ‘backend-enabled-p’
symbol)) ¶Get the beat that OBJECT occurs on, relative to its context’s start. For example, for an ‘event’, the beat is relative to the start of its source pattern, while for a ‘pstream’ or clock object, the beat is the number of beats that have passed since its start.
See also: ‘tempo’
clock)) ¶The number of beats that have elapsed since the creation of the clock.
beat.
pstream)) ¶The number of beats that have elapsed since the start of the pstream.
beat.
(eql cl-patterns:eop))) ¶null)) ¶"Beat subseq" - get a list of all events from OBJECT whose ‘beat’ is START-BEAT or above, and below END-BEAT.
See also: ‘events-in-range’
Get a chord by name.
The indexes of the notes from the scale that the chord is made up of.
symbol)) ¶The octave ratio of the chord (i.e. what to multiply a pitch by to increase its octave by 1).
symbol)) ¶The scale that the chord is derived from.
symbol)) ¶Volume in decibels (dB).
The number of beats between the start of this event and the start of the next one.
See also: ‘dur’, ‘sustain’
The total duration of the note, in beats.
See also: ‘delta’, ‘legato’
End a task; it will stop when its current loop completes.
The end-quant of OBJECT; a list representing when OBJECT is allowed to end playing or when a ‘pdef’ is allowed to swap to a new definition if it has been redefined. Note that if ‘end-quant’ is not set (the default), the pattern can only end or swap when the pattern itself ends (i.e. when it yields ‘eop’).
See ‘quant’ for more information on quants and a description of acceptable values.
See also: ‘quant’, ‘play-quant’, ‘next-beat-for-quant’, ‘beat’, ‘end’, ‘pdef’
Returns t if PSTREAM has no more outputs, or nil if outputs remain to be yielded.
Example:
;; (defparameter *pstr* (as-pstream (pseq ’(1 2) 1)))
;; (next *pstr*) ;=> 1
;; (ended-p *pstr*) ;=> NIL
;; (next *pstr*) ;=> 2
;; (ended-p *pstr*) ;=> NIL
;; (next *pstr*) ;=> NIL
;; (ended-p *pstr*) ;=> T
See also: ‘eop-p’, ‘last-output’
True if OBJECT indicates the end of a pstream’s outputs.
See also: ‘ended-p’
Add EVENT to ESEQ. If EVENT doesn’t have a ‘beat’, it is placed after the last event in ESEQ.
See also: ‘eseq-remove’
The list of events in the ‘eseq’.
Note that eseq’s events slot should not be modified directly as it expects its events to be kept in order. Instead, use ‘eseq-add’, ‘eseq-remove’, or setf ‘eseq-events’.
Remove EVENT from ESEQ.
See also: ‘eseq-add’
The raw plist containing the key/value pairs of the event.
Frequency of the note, in Hz.
See also: ‘rate’, ‘midinote’, ‘degree’
The instrument or synth to trigger.
Insert PATTERN into IPSTREAM at START-BEAT. START-BEAT defaults to the ipstream’s current beat.
ipstream-pstream) pattern &optional start-beat) ¶Play a new copy of OBJECT on the clock. Unlike ‘play’, calling this method on a ‘pdef’ will always start a new copy of its pattern instead of the pdef itself.
See also: ‘play’
How long the note should be held, in beats, as a factor of its total duration (‘dur’).
See also: ‘sustain’, ‘dur’
Whether or not OBJECT should play again after it ends.
Make a backend of the specified type.
See also: ‘backend-start’
MIDI note number of the note (0-127).
Get the next value of a pstream, function, or other object, advancing the pstream forward in the process.
See also: ‘next-n’, ‘next-upto-n’, ‘peek’
eseq-pstream)) ¶ptrack-pstream)) ¶pcycles-pstream)) ¶pbjorklund-pstream)) ¶pmeta-pstream)) ¶pdef-pstream)) ¶pmouse-pstream)) ¶pfilter-pstream)) ¶ipstream-pstream)) ¶ps-pstream)) ¶paccum-pstream)) ¶paclump-pstream)) ¶pclump-pstream)) ¶pparchain-pstream)) ¶pwalk-pstream)) ¶pts-pstream)) ¶ppar-pstream)) ¶pdrop-pstream)) ¶pdelta-pstream)) ¶pdiff-pstream)) ¶pchain-pstream)) ¶psym-pstream)) ¶prun-pstream)) ¶pindex-pstream)) ¶ptime-pstream)) ¶pbeat*-pstream)) ¶pbeat-pstream)) ¶pdurstutter-pstream)) ¶psync-pstream)) ¶pfindur-pstream)) ¶pfin-pstream)) ¶parp-pstream)) ¶pif-pstream)) ¶pscratch-pstream)) ¶phistory-pstream)) ¶pslide-pstream)) ¶prerange-pstream)) ¶pnary-pstream)) ¶ppatlace-pstream)) ¶place-pstream)) ¶ptrace-pstream)) ¶pgeom-pstream)) ¶pseries-pstream)) ¶pgauss-pstream)) ¶pexprand-pstream)) ¶pbrown-pstream)) ¶pwhite-pstream)) ¶pshuf-pstream)) ¶pn-pstream)) ¶protate-pstream)) ¶plazy-pstream)) ¶pr-pstream)) ¶pfunc-pstream)) ¶pwxrand-pstream)) ¶pwrand-pstream)) ¶pxrand-pstream)) ¶prand-pstream)) ¶pk-pstream)) ¶pser-pstream)) ¶pseq-pstream)) ¶pbind-pstream)) ¶function)) ¶Stereo panning, where -1 is fully left, 1 is fully right, and 0 is center.
Get the value of PATTERN’s metadata for KEY. Returns true as a second value if the metadata had an entry for KEY, or nil if it did not.
The source object that this object was created from. For example, for a ‘pstream’, this would be the pattern that ‘as-pstream’ was called on.
The name ("key") of PDEF.
The pattern that PDEF points to.
The currently-playing pstream of PDEF’s pattern.
The task that PDEF was last being played in.
"Peek" at the next value of a pstream, without advancing its current position.
See also: ‘next’, ‘peek-n’, ‘peek-upto-n’
Play an object (typically an event or pattern).
See also: ‘launch’, ‘stop’
The play-quant of OBJECT; a list representing when OBJECT is allowed to begin playing. Defaults to (1).
See ‘quant’ for more information on quants and a description of acceptable values.
See also: ‘quant’, ‘end-quant’, ‘next-beat-for-quant’, ‘beat’, ‘play’
Whether OBJECT is playing.
See also: ‘play-or-stop’, ‘play-or-end’, ‘playing-pdefs’, ‘playing-nodes’
The number of pstreams that have been made of this pattern.
pstream)) ¶How many times a pstream was made of this pstream’s source prior to this pstream. For example, if it was the first time ‘as-pstream’ was called on the pattern, this will be 0.
pstream)) ¶How many times a pstream was made of this pstream’s source prior to this pstream. For example, if it was the first time ‘as-pstream’ was called on the pattern, this will be 0.
Get the value of a cell from ptrack (i.e. the value at that location if specified, or the generated value if not specified). Can also be used on a ptrack-pstream to get the generated values from it. Returns three values:
- the value of the cell
- the name of the key that the specified KEY was derived from, or nil if it was not found
- t if the output was taken from the row itself, or nil if it was derived from the header
See also: ‘ptrack’, ‘ptrack-row’
ptrack-pstream) row key &key if-does-not-exist) ¶Get the plist for ROW from PTRACK.
Get the list of rows from PTRACK.
The quant of OBJECT; a list representing when OBJECT is allowed to begin playing (‘play-quant’), end playing (‘end-quant’), or when a ‘pdef’ is allowed to swap to its new definition (‘end-quant’). ‘quant’ will return the value of ‘play-quant’ as its first value and ‘end-quant’ as its second, and sets both ‘play-quant’ and ‘end-quant’ when it is setf.
A quant value takes the form (divisor phase offset) where all provided elements are numbers. Only the first element is required.
- "divisor" is the divisor to quantize the clock to. The next time (mod (beat *clock*) divisor) is 0 is when OBJECT will start playing.
- "phase" is the number of beats to add on to the position determined by "divisor".
- "offset" is the number of seconds to add on to the position determined by "divisor" and "phase".
For example, a quant of (4) means it can start on any clock beat that is divisible by 4 (0, 4, 8, etc). A quant of (4 2) means the pstream can start 2 beats after any beat divisible by 4 (2, 6, 10, etc). And a quant of (4 0 1) means that the pstream can start 1 second after any beat that is divisible by 4.
See also: ‘play-quant’, ‘end-quant’, ‘next-beat-for-quant’, ‘beat’, ‘play’
Playback rate, i.e. for playing back sound buffers. 1 is normal speed, 2 is twice as fast, 0.5 half as fast, etc.
Render a pattern or other object as audio or other format. OUTPUT is what the pattern should be rendered as. It can be one of the following values:
- A string or pathname - Output file name (file format is determined by the file extension).
- :file - Render to a file in the ‘*cl-patterns-temporary-directory*’.
- :buffer - Render to a buffer in memory.
- :bdef - Render to a ‘bdef:bdef’ buffer object in memory. This output type is only available if the bdef library is loaded, and falls back to :buffer if it is not.
- :score - Render as a "score" in memory, i.e. the sequence type supported by the backend.
- :eseq - Make an ‘eseq’ from the pattern. Effectively defers to ‘as-eseq’.
- :pstream - Make a ‘pstream’ from the pattern. Effectively defers to ‘as-pstream’.
- :list - Get a list of up to the first MAX-LENGTH outputs from this object using ‘next-upto-n’.
The following additional keyword arguments are also supported, depending on the output type:
- BACKEND - The backend to render with. Defaults to the first applicable backend, based on (in descending order of priority): the first event’s :backend key, the first event’s :instrument, or the first enabled backend that supports the specified output type.
- OUTPUT-FILENAME - The filename to write the rendered file to (when rendering to a file).
- TEMPO - The tempo of the result in beats per second. Defaults to ‘*clock*”s current tempo.
- MAX-LENGTH - Maximum number of outputs to grab from the source pattern. Must be an integer (cannot be :inf). Defaults to ‘*max-pattern-yield-length*’.
- DURATION - The total duration of the output in seconds.
- MAX-DURATION - The maximum duration of the output in seconds. Defaults to infinite, in which case the pattern is limited by MAX-PATTERN-YIELD-LENGTH.
See also: ‘as-eseq’
pathname) &rest args &key &allow-other-keys) ¶string) &rest args &key &allow-other-keys) ¶(eql :score)) &rest args &key &allow-other-keys) ¶(eql :file)) &rest args &key &allow-other-keys) ¶(eql :buffer)) &rest args &key &allow-other-keys) ¶(eql :list)) &key max-length) ¶(eql :pstream)) &key) ¶(eql :eseq)) &key) ¶Whether or not something is a rest or a rest-representing object (i.e. :rest, :r, or a rest event).
Get either a musical scale object by its name, or get the name of the scale of an event.
The full name of the scale.
symbol)) ¶The degrees of the scale.
symbol)) ¶The number of pitches per octave in the scale’s ‘tuning’.
symbol)) ¶The scale’s ‘tuning’.
symbol)) ¶Immediately stop a playing object (typically a pattern, pdef, task, or node). If OBJECT is T, stop all playing patterns and nodes.
See also: ‘end’, ‘play’
How long the note should be held, in beats.
See also: ‘legato’, ‘delta’
The number of times to yield the value.
The value that is yielded by the t-pstream.
Get the tempo of OBJECT in beats per second. If OBJECT is a number, set the tempo of ‘*clock*’ to that number.
See also: ‘beat’
Get a tuning by name.
The full name of the tuning.
symbol)) ¶The octave ratio of the tuning (i.e. what to multiply a pitch by to increase its octave by 1).
The actual semitone values of the tuning.
symbol)) ¶The number of pitches per octave in the tuning.
symbol)) ¶pstream) length &key initial-element initial-contents) ¶sb-sequence.
pstream) length &key initial-element initial-contents) ¶sb-sequence.
pdurstutter) stream) ¶pdef-pstream) stream) ¶pbind-pstream) stream) ¶pbjorklund) stream) ¶Method combination type for patterns; specifically, the ‘next’ function. Similar to the standard CLOS method combination, except that :around methods are called in reverse order, from the least specific to the most specific.
next.
Abstract superclass for backends.
(setf backend-enabled-p).
backend-enabled-p.
(setf backend-input-processors).
backend-input-processors.
(setf backend-metadata).
backend-metadata.
(setf backend-name).
backend-name.
backend-responds-p.
backend-start.
backend-start.
(setf backend-started-p).
backend-started-p.
backend-stop.
initialize-instance.
The name of the backend instance.
alexandria:string-designator
:name
Whether this backend instance is currently enabled. Events being played will only be sent to enabled and running backends.
boolean
t
:enabled-p
Whether the backend is current enabled and running.
boolean
:started-p
List of functions that process incoming events. Similar to ‘*post-pattern-output-processors*’ but per-backend.
list
:input-processors
Additional metadata associated with the backend instance.
list
:metadata
Chord definition.
sequence.
The full name of the chord.
:name
The indexes of the notes from the scale that the chord is made up of.
:indexes
The scale that the chord is derived from.
:scale
pattern.
sequence.
list
(list)
:events
This slot is read-only.
The duration of the eseq. If the slot is nil, it defaults to ‘last-dur’ rounded up to the next multiple of the eseq’s ‘play-quant’.
(or null number)
:dur
pstream for ‘eseq’.
Class representing a musical event.
%beat.
(setf amp).
amp.
as-eseq.
(setf beat).
beat.
(setf db).
db.
(setf delta).
delta.
(setf dur).
dur.
eop-p.
eseq-add.
eseq-remove.
event-plist.
(setf freq).
freq.
(setf instrument).
instrument.
keys.
(setf legato).
legato.
(setf loop-p).
loop-p.
(setf midinote).
midinote.
(setf pan).
pan.
play.
(setf play-quant).
play-quant.
print-object.
(setf quant).
quant.
(setf rate).
rate.
render.
(setf rest-p).
rest-p.
(setf scale).
scale.
(setf sustain).
sustain.
(setf tempo).
tempo.
The plist containing all of the event’s keys and values.
list
:event-plist
This slot is read-only.
Insertable pstream; a pstream that can be changed while it’s running by inserting new patterns at a specified beat.
pstream for ‘ipstream’.
(bordeaux-threads:make-recursive-lock "ipstream patterns slot lock")
:lock
Numeric accumulator. Each output and STEP is used as the input for OPERATOR to generate the next output. When LO, HI, and BOUND-BY are provided, outputs that fall outside the range LO..HI are wrapped back inside with the BOUND-BY function; the value is provided as its first argument, and LO and HI are provided as its second and third.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-upto-n (paccum #’+ 0 1) 5) ; same as (pseries 0 1)
;; ;=> (0 1 2 3 4)
;; (next-upto-n (paccum #’+ 0 1 :inf :lo 0 :hi 3 :bound-by #’wrap) 9) ; same as above, wrapping between 0 and 3.
;; ;=> (0 1 2 0 1 2 0 1 2)
See also: ‘pseries’, ‘pgeom’, ‘pwalk’
(function +)
:operator
0
:start
common-lisp.
1
:step
common-lisp.
cl-patterns:*default-pattern-length*
:length
:lo
:hi
:bound-by
pstream for ‘paccum’.
Automatically group outputs of the source pattern into lists of up to N items each. Unlike ‘pclump’, clump size is automatically set to the length of the longest list in the values of ‘*event*’, or 1 if there are no lists.
Example:
;; (next-upto-n (pbind :foo (pseq ’((1) (1 2) (1 2 3)) 1) :bar (paclump (pseries))))
;; ;=> ((EVENT :FOO (1) :BAR (0)) (EVENT :FOO (1 2) :BAR (1 2)) (EVENT :FOO (1 2 3) :BAR (3 4 5)))
See also: ‘pclump’
:pattern
pstream for ‘paclump’.
next.
Arpeggiator pattern; each event yielded by PATTERN is bound to ‘*event*’ and then the entirety of the ARPEGGIATOR pattern is yielded.
Example:
;; (next-upto-n (parp (pbind :foo (pseq ’(1 2 3) 1))
;; (pbind :bar (pseq ’(4 5 6) 1))))
;; ;=> ((EVENT :FOO 1 :BAR 4) (EVENT :FOO 1 :BAR 5) (EVENT :FOO 1 :BAR 6)
;; (EVENT :FOO 2 :BAR 4) (EVENT :FOO 2 :BAR 5) (EVENT :FOO 2 :BAR 6)
;; (EVENT :FOO 3 :BAR 4) (EVENT :FOO 3 :BAR 5) (EVENT :FOO 3 :BAR 6))
See also: ‘psym’, ‘pmeta’, ‘pr’
pstream for ‘parp’.
Abstract pattern superclass.
eseq.
ipstream.
paccum.
paclump.
parp.
pbeat.
pbeat*.
pbind.
pbjorklund.
pbrown.
pchain.
pclump.
pcycles.
pdef.
pdelta.
pdiff.
pdrop.
pdurstutter.
pexprand.
pfilter.
pfin.
pfindur.
pfunc.
pgauss.
pgeom.
phistory.
pif.
pindex.
pk.
place.
plazy.
pmeta.
pmouse.
pn.
pnary.
ppar.
ppatlace.
pr.
prand.
prerange.
protate.
prun.
ps.
pscratch.
pseq.
pser.
pseries.
pshuf.
pslide.
pstream.
psym.
psync.
ptime.
ptrace.
ptrack.
pts.
pwalk.
pwhite.
pwrand.
pwxrand.
pxrand.
%pattern-children.
as-eseq.
as-pstream.
dur.
(setf end-condition).
end-condition.
(setf end-quant).
end-quant.
events-in-range.
initialize-instance.
launch.
(setf loop-p).
loop-p.
next.
pattern-metadata.
(setf pattern-source).
pattern-source.
peek.
play.
(setf play-quant).
play-quant.
playing-p.
(setf pstream-count).
pstream-count.
A list of numbers representing when the pattern’s pstream can start playing. See ‘play-quant’ and ‘quant’.
:play-quant
A list of numbers representing when a pattern can end playing and when a ‘pdef’ can be swapped out for a new definition. See ‘end-quant’ and ‘quant’.
list
:end-quant
Nil or a function that is called by the clock with the pattern as its argument to determine whether the pattern should end or swap to a new definition.
(or null function)
:end-condition
The source object that this object was created from. For example, for a ‘pstream’, this would be the pattern that ‘as-pstream’ was called on.
:source
When a pattern is embedded in another pattern, the embedded pattern’s parent slot points to the pattern it is embedded in.
:parent
Whether or not the pattern should loop when played.
:loop-p
A list of functions that are run when the pattern ends or is stopped.
:cleanup
The number of pstreams that have been made of this pattern.
0
Hash table of additional data associated with the pattern, accessible with the ‘pattern-metadata’ function.
hash-table
(make-hash-table)
:metadata
Yield the number of beats elapsed since the pbeat was embedded in the pstream.
Example:
;; (next-n (pbind :dur (pseq ’(1 2 3)) :foo (pbeat)) 3)
;; ;=> ((EVENT :DUR 1 :FOO 0) (EVENT :DUR 2 :FOO 1) (EVENT :DUR 3 :FOO 3))
See also: ‘pbeat*’, ‘beat’, ‘prun’
Yield the number of beats on the ‘*clock*’ of the current pattern. In other words, pbeat* is clock-synced, unlike ‘pbeat’, which is pattern-synced.
Example:
;; (next-n (pbind :dur (pseq ’(1 2 3)) :foo (pbeat*)) 3)
;; ;=> ((EVENT :DUR 1 :FOO 200) (EVENT :DUR 2 :FOO 201) (EVENT :DUR 3 :FOO 203))
See also: ‘pbeat’, ‘beat’, ‘prun’
pstream for ‘pbeat*’.
pbind yields events determined by its PAIRS, which are a list of keys and values. Each key corresponds to a key in the resulting events, and each value is treated as a pattern that is evaluated for each step of the pattern to generate the value for its key.
Example:
;; (next-n (pbind :foo (pseq ’(1 2 3)) :bar :hello) 4)
;;
;; ;=> ((EVENT :FOO 1 :BAR :HELLO) (EVENT :FOO 2 :BAR :HELLO) (EVENT :FOO 3 :BAR :HELLO) EOP)
See also: ‘pmono’, ‘pb’
The pattern pairs of the pbind; a plist mapping its keys to their values.
:pairs
pstream for ‘pbind’
pbjorklund generates Euclidean rhythms using the Bjorklund algorithm. PULSES is the number of notes in the sequence, and STEPS is number of steps in the sequence. Additionally, OFFSET is the number to rotate the sequence by, DUR is the total duration one repeat of the sequence should be, and REPEATS is the number of repeats that should be yielded. This pattern outputs events which can be embedded into another pattern. Each pulse is a note, and each subdivision of the sequence that is not a pulse is a rest. If you just want the raw output from the Bjorklund algorithm (not in pattern form), use ‘bjorklund’ instead.
Example:
;; (next-upto-n (pbjorklund 3 7))
;; => ((EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :NOTE :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7) (EVENT :TYPE :REST :DUR 1/7))
See also: ‘bjorklund’
:pulses
:steps
0
:offset
1
:dur
cl-patterns:*default-pattern-repeats*
:repeats
pstream for ‘pbjorklund’.
next.
Brownian motion within a range; each output randomly a maximum of STEP away from the previous. LO and HI define the lower and upper bounds of the range. STEP defaults to 1 if LO and HI are integers.
Example:
;; (next-upto-n (pbrown 0 10 1 10))
;; ;=> (2 3 3 3 4 3 4 5 6 5)
See also: ‘pwhite’, ‘pexprand’, ‘pgauss’
0.0
:lo
1.0
:hi
common-lisp.
0.125
:step
common-lisp.
cl-patterns:*default-pattern-length*
:length
pstream for ‘pbrown’.
Combine multiple patterns into one event stream.
Example:
;; (next-n (pchain (pbind :foo (pseq ’(1 2 3))) (pbind :bar (pseq ’(7 8 9) 1))) 4)
;;
;; ;=> ((EVENT :FOO 1 :BAR 7) (EVENT :FOO 2 :BAR 8) (EVENT :FOO 3 :BAR 9) NIL)
See also: ‘pbind”s :embed key
:patterns
pstream for ‘pchain’.
next.
Group outputs of the source pattern into lists of up to N items each.
Example:
;; (next-upto-n (pclump (pseries 0 1 5) 2))
;; ;=> ((0 1) (2 3) (4))
See also: ‘paclump’
pstream for ‘pclump’.
next.
pcycles yields values from LIST as events whose dur is (/ 1 list-length) and whose value is the original value in the list. This process recurses into sublists, subdividing their durs equally among the sublist’s contents to be a fraction of what their dur originally would be. The total dur yielded by pcycles is always equal to 1. pcycles repeats the whole LIST once.
common-lisp.
:list
common-lisp.
:map
:value
:key
1
:dur
cl-patterns:*default-pattern-repeats*
:repeats
pstream for ‘pcycles’.
Define a named pattern, with NAME being the name of the pattern and PATTERN the pattern itself. Named patterns are stored in a global dictionary and can be referred back to by calling ‘pdef’ without supplying PATTERN. The global dictionary also keeps track of the pdef’s pstream when ‘play’ is called on it. If a pdef is redefined while it is being played, the changes won’t be audible until either PATTERN ends, or the pdef’s ‘end-quant’ time is reached (if non-nil). Note that, unlike bare patterns, pdefs loop by default when played (‘loop-p’).
Example:
;; (pdef :foo (pbind :degree (pseries 0 1 4)))
;;
;; (play (pdef :foo))
;; ;; redefine the pdef’s pattern... note that the redefinition doesn’t become audible until the current loop finishes playing:
;; (pdef :foo (pbind :degree (pseries 4 -1 4)))
See also: ‘find-pdef’, ‘all-pdefs’, ‘pb’, ‘pmeta’, ‘ps’
alexandria:string-designator
:name
This slot is read-only.
:pattern
:pstream
:task
pstream for ‘pdef’.
:current-pstream
Output the difference between successive outputs of PATTERN, assuming PATTERN restarts every CYCLE outputs.
Unlike ‘pdiff’, pdelta is written with its use as input for ‘pbind”s :delta key in mind. If PATTERN’s successive values would result in a negative difference, pdelta instead wraps the delta around to the next multiple of CYCLE. This would allow you to, for example, supply the number of the beat that each event occurs on, rather than specifying the delta between each event. This is of course achievable using pbind’s :beat key as well, however that method requires the pbind to peek at future values, which is not always desirable.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-n (pdelta (pseq ’(0 1 2 3)) 4) 8)
;;
;; ;=> (1 1 1 1 1 1 1 1)
;;
;; (next-n (pdelta (pseq ’(0 1 2 5)) 4) 8)
;;
;; ;=> (1 1 3 3 1 1 3 3)
See also: ‘pdiff’, ‘pbind”s :beat key
pstream for ‘pdelta’.
next.
Output the difference between successive outputs of PATTERN.
Example:
;; (next-n (pdiff (pseq ’(3 1 4 3) 1)) 4)
;;
;; ;=> (-2 3 -1 NIL)
See also: ‘pdelta’
:pattern
Drop the first N outputs from PATTERN and yield the rest. If N is negative, drop the last N outputs from PATTERN instead.
Example:
;; (next-n (pdrop (pseq ’(1 2 3 4) 1) 2) 4)
;;
;; ;=> (3 4 NIL NIL)
See also: ‘protate’
Yield each output from PATTERN N times, dividing it by N. If the output from PATTERN is an event, its dur is divided; if it’s a number, the number itself is divided instead of being yielded directly.
Example:
;; (next-n (pdurstutter (pseq ’(1 2 3 4 5)) (pseq ’(3 2 1 0 2))) 9)
;; ;=> (1/3 1/3 1/3 1 1 3 5/2 5/2 NIL)
;;
;; (next-n (pdurstutter (pbind :dur (pseq ’(1 2 3 4 5)))
;; (pseq ’(3 2 1 0 2)))
;; 9)
;; ;=> ((EVENT :DUR 1/3) (EVENT :DUR 1/3) (EVENT :DUR 1/3) (EVENT :DUR 1) (EVENT :DUR 1) (EVENT :DUR 3) (EVENT :DUR 5/2) (EVENT :DUR 5/2) NIL)
See also: ‘pr’
pstream for ‘pdurstutter’.
Exponentially-distributed random numbers between LO and HI. Note that LO and HI cannot be 0, and that LO and HI must have the same sign or else complex numbers will be output.
Example:
;; (next-upto-n (pexprand 1.0 8.0 4))
;; ;=> (1.0420843091865208d0 1.9340168112124456d0 2.173209129035095d0 4.501371557329618d0)
See also: ‘pwhite’, ‘pbrown’, ‘pgauss’, ‘prand’
pstream for ‘pexprand’.
Skip elements of a source pattern that PREDICATE returns false for. If PREDICATE is not a function, skip items that are ‘eql’ to it.
Example:
;; (next-n (pfilter (pseq (list 1 2 3))
;; 2)
;; 6)
;; ;=> (1 3 1 3 1 3)
;; (next-n (pfilter (pseries 0 1) ’evenp)
;; 6)
;; ;=> (1 3 5 7 9 11)
See also: ‘pfilter-out’, ‘pr’, ‘pdurstutter’
pstream for ‘pfilter’.
next.
Yield up to COUNT outputs from PATTERN.
Example:
;; (next-n (pfin (pseq ’(1 2 3) :inf) 3) 5)
;; ;=> (1 2 3 NIL NIL)
See also: ‘pfindur’
Yield events from PATTERN until their total duration is within TOLERANCE of DUR, or greater than DUR. Any events that would end beyond DUR are cut short. If PATTERN outputs numbers, their total sum is limited instead.
Example:
;; (next-n (pfindur (pbind :dur 1 :foo (pseries)) 2) 3)
;; ;=> ((EVENT :DUR 1 :FOO 0) (EVENT :DUR 1 :FOO 1) EOP)
;;
;; (next-upto-n (pfindur (pwhite 0 4) 16))
;; ;=> (1 3 0 1 2 2 1 3 0 1 2)
;; (reduce #’+ *)
;; ;=> 16
See also: ‘pfin’, ‘psync’
pstream for ‘pfindur’.
Yield the result of evaluating FUNC. Note that the current event of the parent pattern is still accessible via the ‘*event*’ special variable.
Example:
;; (next-upto-n (pfunc (lambda () (random 10)) 4))
;; ;=> ((5 2 8 9))
;;
;; (next-upto-n (pbind :foo (pwhite 0 10 4)
;; :bar (pfunc (lambda ()
;; (if (> (event-value *event* :foo) 5) :greater :lesser)))))
;; ;=> ((EVENT :FOO 0 :BAR :LESSER) (EVENT :FOO 6 :BAR :GREATER)
;; (EVENT :FOO 7 :BAR :GREATER) (EVENT :FOO 8 :BAR :GREATER))
See also: ‘pf’, ‘pnary’, ‘plazy’, ‘pif’
pstream for ‘pfunc’.
Random numbers distributed along a normal (gaussian) curve. MEAN is the "center" of the distribution, DEVIATION is the standard deviation (i.e. the higher the value, the further the outputs are spread from MEAN).
Example:
;; (next-n (pgauss) 4)
;; ;=> (0.08918811646370092d0 0.1745957067161632d0 0.7954678768273173d0 -1.2215823449671597d0)
See also: ‘pwhite’, ‘pexprand’, ‘pbrown’
pstream for ‘pgauss’.
Yield START, then generate subsequent outputs by multiplying by GROW, for a total of LENGTH outputs.
Example:
;; (next-upto-n (pgeom 1 2 4))
;; ;=> (1 2 4 8)
See also: ‘pseries’, ‘paccum’
pstream for ‘pgeom’.
Refer back to PATTERN’s history, yielding the output at the index provided by STEP-PATTERN.
Note that PATTERN is still advanced once per event, and if STEP-PATTERN yields a number pointing to an event in PATTERN that hasn’t been yielded yet (i.e. if PATTERN has only advanced once but STEP-PATTERN yields 3 for its output), phistory yields nil.
Example:
;; (next-n (phistory (pseries) (pseq ’(0 2 1))) 3)
;; ;=> (0 NIL 1)
See also: ‘pscratch’
pstream for ‘phistory’.
next.
"If" expression for patterns. TEST is evaluated for each step, and if it’s non-nil, the value of TRUE will be yielded, otherwise the value of FALSE will be. Note that TRUE and FALSE can be patterns, and if they are, they are only advanced in their respective cases, not for every step.
Example:
;; (next-n (pif (pseq ’(t t nil nil nil)) (pseq ’(1 2 3)) (pseq ’(9 8 7))) 8)
;; ;=> (1 2 9 8 7 3 1 9)
See also: ‘plazy’, ‘pfunc’
Use INDEX-PAT to index into the list returned by LIST-PAT. WRAP-P is whether indexes that are out of range will be wrapped (if t) or will simply return nil.
Example:
;; (next-n (pindex (list 99 98 97) (pseq (list 0 1 2 3))) 4)
;;
;; ;=> (99 98 97 NIL)
;;
;; (next-upto-n (pindex (list 99 98 97) (pseries 0 1 6) t))
;;
;; ;=> (99 98 97 99 98 97)
See also: ‘pwalk’
pstream for ‘pindex’.
next.
Yield the value of KEY in the current ‘*event*’ context, returning DEFAULT if that value is nil.
Example:
;; (next-upto-n (pbind :foo (pseq ’(1 2 3) 1) :bar (pk :foo)))
;; ;=> ((EVENT :FOO 1 :BAR 1) (EVENT :FOO 2 :BAR 2) (EVENT :FOO 3 :BAR 3))
See also: ‘pbind’, ‘event-value’, ‘*event*’
Yield each value from LIST in sequence. If the value is a list, the first element of that list is yielded. The second time that sub-list is encountered, its second element will be yielded; the third time, the third element, and so on. REPEATS controls the number of times LIST is repeated.
Example:
;; (next-upto-n (place (list 1 2 (list 3 4 5)) 3))
;; ;=> (1 2 3 1 2 4 1 2 5)
See also: ‘ppatlace’
pstream for ‘place’.
Evaluates FUNC to generate a pattern, which is then yielded from until its end, at which point FUNC is evaluated again to generate the next pattern. The pattern is generated a total of REPEATS times.
Example:
;; (next-n (plazy (lambda () (if (= 0 (random 2)) (pseq ’(1 2 3) 1) (pseq ’(9 8 7) 1)))) 6)
;; ;=> (9 8 7 1 2 3)
See also: ‘pfunc’
pstream for ‘plazy’.
Meta-control patterns using the events output by PATTERN. In other words, instead of triggering synths directly, the events output by PATTERN are used to embed patterns into the pmeta’s pstream.
The following keys are supported:
- :pattern or :instrument - name of the source pattern for this "step".
- :dur - set the duration of the embedded pattern (defaults to :inf, which causes the pattern to play to its end).
- :findur - limit the duration of the embedded pattern.
- :sync - sync the duration of the embedded pattern to a multiple of the provided value, similar to ‘psync’
- :stretch - multiply the duration of each of the source pattern’s events.
- :ts or :fit - timestretch a pattern so its total duration is the number specified, a la ‘pts’.
- :r or :repeat - repeat each event the number of times returned by the function when the event is applied to it, similar to ‘pr’.
- :inject - inject key/value pairs from the output of this value into the source pattern.
- :step-inject or :sinject - inject one output from this value per step.
The following keys are planned for future implementation:
- :start or :end - adjust the start or end points of the source pattern (i.e. to skip the first half, set :start to 0.5).
- :start-beat or :end-beat - adjust the start or end points of the source pattern in number of beats (i.e. to end the pattern 2 beats early, set :end-beat to -2).
- :start-nth or :end-nth - adjust the start or end points of the source pattern by skipping the first or last N events.
- :filter or :remove-if-not - skip all events from the source pattern that return nil when applied to the specified function or pattern.
- :mapcar or :nary - process each event from the source pattern with a function or another pattern.
See doc/special-keys.org for more information on these keys.
Example:
;; ;; define a few patterns...
;; (pdef :foo (pbind :x (pseq ’(1 2 3) 1) :dur 1))
;; (pdef :bar (pbind :y (pseries) :dur (pwhite 0.1 1.0 3)))
;;
;; ;; use pmeta to play pattern foo and then pattern bar, ensuring each are 2 beats long in total by way of pmeta’s sync key, which works similarly to ‘psync’
;; (next-upto-n (pmeta :pattern (pseq (list :foo :bar) 1) :sync 2))
;; ;=> ((EVENT :X 1 :DUR 1) (EVENT :X 2 :DUR 1) ; from (pdef :foo)
;; (EVENT :Y 0 :DUR 0.76958686) (EVENT :Y 1 :DUR 0.94850993) (EVENT :Y 2 :DUR 0.28190327)) ; from (pdef :bar)
See also: ‘psym’, ‘parp’, ‘pdef’, ‘pbind’
as-pstream.
print-object.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
process-pattern-key-value.
:pattern
pstream for ‘pmeta’.
Get the mouse position of the display server (GUI). ORIENTATION can be :x or :y, and FORMAT can be either :relative (in which case the output is a number from 0 to 1 as a fraction of total display size) or :absolute (in which case the output is the actual X or Y position of the mouse).
See also: ‘pmousex’, ‘pmousey’, ‘mouse-location’
pstream for ‘pmouse’.
next.
Embed the full PATTERN into the pstream REPEATS times.
Example:
;; (next-upto-n (pn (pwhite 0 5 1) 5))
;; ;=> (2 4 2 1 0)
See also: ‘pr’
pstream for ‘pn’.
Yield the result of applying OPERATOR to each value yielded by each pattern in PATTERNS.
Example:
;; (next-upto-n (pnary (pseq (list ’+ ’- ’* ’/) 2) 2 2))
;; ;=> (4 0 4 1)
See also: ‘pfunc’, ‘p+’, ‘p-’, ‘p*’, ‘p/’
Combine multiple event patterns into one pstream with all events in temporal order. PATTERNS is the list of patterns, or a pattern yielding lists of patterns. The ppar ends when all of the patterns in PATTERNS end.
Example:
;; (next-upto-n (ppar (list (pbind :dur (pn 1/2 4))
;; (pbind :dur (pn 2/3 4)))))
;;
;; ;=> ((EVENT :DUR 1/2 :DELTA 0) (EVENT :DUR 2/3 :DELTA 1/2)
;; (EVENT :DUR 1/2 :DELTA 1/6) (EVENT :DUR 2/3 :DELTA 1/3)
;; (EVENT :DUR 1/2 :DELTA 1/3) (EVENT :DUR 2/3 :DELTA 1/6)
;; (EVENT :DUR 1/2 :DELTA 1/2) (EVENT :DUR 2/3 :DELTA 2/3))
See also: ‘psym’
:patterns
pstream for ‘ppar’.
Combine multiple patterns into several event streams. The event yielded by the first pattern will be used as the input event to the second pattern, and so on. The events yielded by each pattern will be collected into a list and yielded by the pparchain. This pattern is effectively ‘ppar’ and ‘pchain’ combined.
Example:
;; (next-upto-n (pparchain (pbind :foo (pseries 0 1 3)) (pbind :baz (p+ (pk :foo) 1) :foo (p+ (pk :foo) 3))))
;; ;=> (((EVENT :FOO 0) (EVENT :FOO 3 :BAZ 1))
;; ((EVENT :FOO 1) (EVENT :FOO 4 :BAZ 2))
;; ((EVENT :FOO 2) (EVENT :FOO 5 :BAZ 3)))
See also: ‘ppc’, ‘ppar’, ‘pchain’, ‘pbind”s :embed key
:patterns
pstream for ‘pparchain’.
next.
Yield each value from LIST in sequence, or one output from each pattern in LIST per cycle of the list. If one of the patterns embedded in LIST ends sooner than the others, it is simply removed and the ppatlace continues to yield from the rest of the LIST. The entire LIST is yielded through a total of REPEATS times.
Example:
;; (next-upto-n (ppatlace (list (pseq (list 1 2 3) 1)
;; (pseq (list 4 5 6) 2))))
;; ;=> (1 4 2 5 3 6 4 5 6)
See also: ‘place’
pstream for ‘ppatlace’.
Repeat each value from PATTERN REPEATS times. If REPEATS is 0, the value is skipped.
Example:
;; (next-upto-n (pr (pseries) (pseq ’(1 3 0 2) 1)))
;; ;=> (0 1 1 1 3 3)
See also: ‘pdurstutter’, ‘pn’, ‘pdrop’, ‘parp’
pstream for ‘pr’.
Yield random values from LIST.
Example:
;; (next-n (prand ’(1 2 3) 5) 6)
;; ;=> (3 2 2 1 1 EOP)
See also: ‘pxrand’, ‘pwrand’, ‘pwxrand’
pstream for ‘prand’.
Remap INPUT from one range, specified by FROM-RANGE, to another range, specified by TO-RANGE.
Note that this is effectively a convenience wrapper over ‘pnary’ and ‘rerange’; thus you should see ‘rerange’ for more information.
See also: ‘rerange’, ‘pnary’
pstream for ‘prerange’.
next.
An object representing a rest. When set as a value in an event, the event’s :type becomes :rest and the prest’s value slot is used as the actual value for the event key instead.
1
:value
Rotate PATTERN N outputs forward or backward, wrapping the shifted items to the other side, a la ‘alexandria:rotate’.
Example:
;; (next-upto-n (protate (pseq ’(1 2 3 4 5) 1) 2))
;; ;=> (4 5 1 2 3)
See also: ‘pdrop’, ‘phistory’, ‘pscratch’
pstream for ‘protate’.
next.
Run PATTERN "independently" of its parent, holding each value for DUR beats. Each of PATTERN’s outputs is treated as if it lasted DUR beats, being continuously yielded during that time before moving on to the next output.
Example:
;; (next-upto-n (pbind :foo (pseq ’(1 2 3 4 5))
;; :bar (prun (pseq ’(4 5 6 7 8))
;; (pseq ’(1 2 0.5 0.5 1)))))
;; ;=> ((EVENT :FOO 1 :BAR 4)
;; (EVENT :FOO 2 :BAR 5)
;; (EVENT :FOO 3 :BAR 5)
;; (EVENT :FOO 4 :BAR 6)
;; (EVENT :FOO 5 :BAR 8))
See also: ‘beat’, ‘pbeat’
pstream for ‘prun’.
Preserve pstream state across subsequent calls to ‘as-pstream’. To reset the pstream, simply re-evaluate the ps definition.
Based on the pattern originally from the miSCellaneous SuperCollider library.
Example:
;; (defparameter *pst* (ps (pseries)))
;;
;; (next-upto-n *pst* 4)
;; ;=> (0 1 2 3)
;;
;; (next-upto-n *pst* 4)
;; ;=> (4 5 6 7)
;;
;; (defparameter *pst* (ps (pseries)))
;;
;; (next-upto-n *pst* 4)
;; ;=> (0 1 2 3)
See also: ‘prs’, ‘pdef’
"Scratches" across the values yielded by a pstream, similar in concept to how a DJ might scratch a record, altering the normal flow of playback. PATTERN is the source pattern, and STEP-PATTERN determines the increment of the index into the pstream history.
Based on the pattern originally from the ddwPatterns SuperCollider library.
Example:
;; (next-upto-n (pscratch (pseries) (pseq ’(0 1 1 -1 2) 2)))
;; ;=> (0 0 1 2 1 3 3 4 5 4)
See also: ‘phistory’
pstream for ‘pscratch’.
Sequentially yield items from LIST, repeating the whole list REPEATS times. OFFSET is the offset to index into the list.
Example:
;; (next-n (pseq ’(5 6 7) 2) 7)
;; ;=> (5 6 7 5 6 7 EOP)
;;
;; (next-upto-n (pseq ’(5 6 7) 2 1))
;; ;=> (6 7 5 6 7 5)
See also: ‘pser’, ‘eseq’
pstream for ‘pseq’.
Sequentially yield values from LIST, yielding a total of LENGTH values.
Example:
;; (next-n (pser ’(5 6 7) 2) 3)
;;
;; ;=> (5 6 EOP)
See also: ‘pseq’
pstream for ‘pser’.
Yield START, then generate subsequent outputs by adding STEP, for a total of LENGTH outputs.
Example:
;; (next-upto-n (pseries 1 2 4))
;; ;=> (1 3 5 7)
See also: ‘pseries*’, ‘pgeom’, ‘paccum’
pstream for ‘pseries’.
Shuffle LIST, then yield each item from the shuffled list, repeating it REPEATS times.
Example:
;; (next-upto-n (pshuf ’(1 2 3) 2))
;;
;; ;=> (3 1 2 3 1 2)
See also: ‘prand’
pstream for ‘pshuf’.
"Slide" across sections of LIST. REPEATS is the total number of sections to output, LEN the length of the section. STEP is the number to increment the start index by after each section, and START is the initial index into LIST that the first section starts from. WRAP-AT-END, when true, means that an index outside of the list will wrap around. When false, indexes outside of the list result in nil.
Example:
;; (next-upto-n (pslide (list 0 1 2 3 4 5 6) 3 3 2 1 t))
;; ;=> (1 2 3 3 4 5 5 6 0)
See also: ‘pscratch’
common-lisp.
:list
cl-patterns:*default-pattern-repeats*
:repeats
3
:len
common-lisp.
1
:step
0
:start
t
:wrap-at-end
pstream for ‘pslide’.
next.
:current-repeats-remaining
:current-repeats
:remaining-current-segment
:current-value
:current-list-length
"Pattern stream". Keeps track of the current state of a pattern in process of yielding its outputs.
pattern.
sequence.
eseq-pstream.
ipstream-pstream.
paccum-pstream.
paclump-pstream.
parp-pstream.
pbeat*-pstream.
pbeat-pstream.
pbind-pstream.
pbjorklund-pstream.
pbrown-pstream.
pchain-pstream.
pclump-pstream.
pcycles-pstream.
pdef-pstream.
pdelta-pstream.
pdiff-pstream.
pdrop-pstream.
pdurstutter-pstream.
pexprand-pstream.
pfilter-pstream.
pfin-pstream.
pfindur-pstream.
pfunc-pstream.
pgauss-pstream.
pgeom-pstream.
phistory-pstream.
pif-pstream.
pindex-pstream.
pk-pstream.
place-pstream.
plazy-pstream.
pmeta-pstream.
pmouse-pstream.
pn-pstream.
pnary-pstream.
ppar-pstream.
ppatlace-pstream.
pr-pstream.
prand-pstream.
prerange-pstream.
protate-pstream.
prun-pstream.
ps-pstream.
pscratch-pstream.
pseq-pstream.
pser-pstream.
pseries-pstream.
pshuf-pstream.
pslide-pstream.
psym-pstream.
psync-pstream.
ptime-pstream.
ptrace-pstream.
ptrack-pstream.
pts-pstream.
pwalk-pstream.
pwhite-pstream.
pwrand-pstream.
pwxrand-pstream.
pxrand-pstream.
t-pstream.
The number of outputs yielded from this pstream and any sub-pstreams that have ended.
common-lisp.
0
The stack of pattern pstreams embedded in this pstream.
(list)
How many times a pstream was made of this pstream’s source prior to this pstream. For example, if it was the first time ‘as-pstream’ was called on the pattern, this will be 0.
integer
:pstream-count
The number of beats that have elapsed since the start of the pstream.
number
0
beat.
This slot is read-only.
The history of outputs yielded by the pstream.
vector
The number of items in this pstream’s history. Differs from the number slot in that all outputs are immediately included in its count.
0
The beat number of the parent pstream when this pstream started.
:start-beat
The number of peeks into the future that have been made in the pstream. For example, if ‘peek’ is used once, this would be 1. If ‘next’ is called after that, future-number decreases back to 0.
0
The current beat including all future outputs (the ‘beat’ slot does not include peeked outputs).
0
Use a pattern of symbols to embed ‘pdef’s. PATTERN is the source pattern that yields symbols naming the pdef to embed.
Example:
;; (pdef :foo (pseq ’(1 2 3) 1))
;;
;; (pdef :bar (pseq ’(4 5 6) 1))
;;
;; (next-upto-n (psym (pseq ’(:foo :bar) 1)))
;;
;; ;=> (1 2 3 4 5 6)
See also: ‘pdef’, ‘ppar’, ‘pmeta’
:pattern
pstream for ‘psym’.
Yield events from PATTERN until their total duration is within TOLERANCE of MAXDUR, cutting off any events that would extend past MAXDUR. If PATTERN ends before MAXDUR, a rest is added to the pstream to round its duration up to the nearest multiple of SYNC-QUANT.
Example:
;; (next-upto-n (psync (pbind :dur (pseq ’(5) 1)) 4 16))
;;
;; ;=> ((EVENT :DUR 5) (EVENT :TYPE :REST :DUR 3))
;;
;; (next-upto-n (psync (pbind :dur (pseq ’(5) 5)) 4 16))
;;
;; ;=> ((EVENT :DUR 5) (EVENT :DUR 5) (EVENT :DUR 5) (EVENT :DUR 5 :DELTA 1))
See also: ‘pfindur’
pstream for ‘psync’.
Yield the number of seconds elapsed since ptime was embedded in the pstream.
Note: May give inaccurate results if the clock’s tempo changes occur more frequently than events in the parent pbind.
Example:
;; (setf (tempo *clock*) 1) ; 60 BPM
;; (next-n (pbind :dur 1 :time (ptime)) 2)
;; ;=> ((EVENT :DUR 1 :TIME 0) (EVENT :DUR 1 :TIME 1.0))
See also: ‘pbeat’, ‘prun’, ‘beat’
pstream for ‘ptime’.
Print the PREFIX and each output of TRACE to STREAM. If TRACE is t, print ‘*event*’. If TRACE is a different symbol, print the value of that symbol in ‘*event*’. If TRACE is a pattern, ptrace yields its output unaffected. Otherwise, it yields t.
See also: ‘debug-backend’, ‘debug-backend-recent-events’
pstream for ‘ptrace’.
next.
Defines an event pattern via a tracker-inspired notation. HEADER is a plist mapping the pattern’s "columns" (keys) to their default values or to patterns that are used to generate the key’s values for each output. ROWS is a list of lists, each sublist specifying the values for a step. Values can be specified on their own (in which case they’re matched in order to the columns specified in the header) or by using Lisp’s traditional key/value notation.
By default, the pattern repeats infinitely, however it can be limited by providing a :repeats argument in the header specifying the number of repeats.
Example:
;; (ptrack (list :freq 440 :dur 1/4)
;; ’((100) ; play a note with a frequency of 100
;; :r ; rest for 1/4 beat
;; (:midinote 70 :dur 1/2) ; play a note at midinote 70 for 1/2 beat
;; (-) ; continue previous note for an additional 1/4 beat
;; (600 3/4) ; play a note with a frequency of 600 for 3/4 beat
;; :r ; rest for 1/4 beat
;; (750 :foo 3) ; play a note at frequency 750, dur 1/4, and additional :foo key with value 3
;; ))
See also: ‘pt’, ‘pcycles’, ‘pbind’
pstream for ‘ptrack’.
Timestretch PATTERN so its total duration is DUR. Note that only the first ‘*max-pattern-yield-length*’ events from PATTERN are considered, and that they are calculated immediately at pstream creation time rather than lazily as the pstream yields.
Example:
;; (next-upto-n (pts (pbind :dur (pn 1 4)) 5))
;;
;; ;=> ((EVENT :DUR 5/4) (EVENT :DUR 5/4) (EVENT :DUR 5/4) (EVENT :DUR 5/4))
See also: ‘pfindur’, ‘psync’
pstream for ‘pts’.
"Walk" over the values in LIST by using the accumulated value of the outputs of STEP-PATTERN as the index. At the beginning of the pwalk and each time the start or end of the list is passed, the output of DIRECTION-PATTERN is taken and used as the multiplier for values from STEP-PATTERN. START-POS is the index in LIST for pwalk to take its first output from.
Example:
;; ;; using (pseq (list 1 -1)) as the DIRECTION-PATTERN causes the pwalk’s output to "ping-pong":
;; (next-n (pwalk (list 0 1 2 3) (pseq (list 1)) (pseq (list 1 -1))) 10)
;;
;; ;=> (0 1 2 3 2 1 0 1 2 3)
See also: ‘pindex’, ‘pbrown’, ‘paccum’
pstream for ‘pwalk’.
Linearly-distributed random numbers between LO and HI, inclusive.
Example:
;; (next-upto-n (pwhite 0 10 16))
;; ;=> (7 2 4 5 7 10 4 8 10 2 3 5 9 2 5 4)
See also: ‘pexprand’, ‘pbrown’, ‘pgauss’, ‘prand’
pstream for ‘pwhite’.
Yield random elements from LIST weighted by respective values from WEIGHTS.
Example:
;; (next-upto-n (pwrand ’(1 2 3) ’(7 5 3) 10))
;; ;=> (1 1 2 2 2 1 2 1 1 3)
See also: ‘prand’, ‘pxrand’, ‘pwxrand’
pstream for ‘pwrand’.
Yield random elements from LIST weighted by respective values from WEIGHTS, never repeating equivalent values twice in a row. This is effectively ‘pxrand’ and ‘pwrand’ combined.
Example:
;; (next-upto-n (pwxrand ’(1 2 3) ’(7 5 3) 10))
;; ;=> (1 2 1 2 1 3 1 2 1 2)
See also: ‘prand’, ‘pxrand’, ‘pwrand’
pstream for ‘pwxrand’.
Yield random values from LIST, never repeating equal values twice in a row.
Example:
;; (next-upto-n (pxrand ’(1 2 3) 4))
;; ;=> (3 1 2 1)
See also: ‘prand’, ‘pwrand’, ‘pwxrand’
pstream for ‘pxrand’.
Scale definition.
Pattern stream object that by default yields its value only once.
Tuning definition.
sequence.
The full name of the tuning.
:name
The actual semitone values of the tuning.
:pitches
The octave ratio of the tuning (i.e. what to multiply a pitch by to increase its octave by 1).
:octave-ratio
List of abbreviations that should be used by ‘generate-aliases’ to auto-generate aliases for ‘tuning’s, ‘scale’s, ‘chord’s, etc.
List of loaded and active cl-patterns backends. This variable generally shouldn’t need to be modified by the user; instead register backends by loading the relevant cl-patterns sub-system, then use ‘make-backend’ and/or ‘backend-start’ to make and activate a backend.
See also: ‘all-backends’, ‘all-backend-types’, ‘make-backend’, ‘backend-start’, ‘backend-stop’
Hash table mapping names and aliases to chord definition objects.
Hash table storing conversion function definitions and metadata.
List of functions that can be used to look up the object that a symbol can name. Each function should return the object in question if it exists, or nil (or throw an error) if it doesn’t.
Functions like ‘play’, ‘end’, ‘launch’, and ‘stop’ will check symbols against each of these dictionaries in order and will apply themselves to the object from the first dictionary with a matching key.
Example:
;; *dictionary-lookup-functions*
;; => (CL-PATTERNS::FIND-PDEF BDEF:BDEF)
;; (play :foo) ; will (play (pdef :foo)) if that pdef exists, or (play (bdef :foo)) if the bdef exists. If neither exists, it will throw an error.
See also: ‘play’, ‘launch’, ‘end’, ‘stop’
Plist mapping event special keys to their case lists.
Hash table mapping instrument names (as symbols) to arbitrary parameter lists. Used by ‘remap-instrument-to-parameters’ as part of post-pattern output processing. Any events whose :instrument is not found in this table will not be affected.
See also: ‘remap-instrument-to-parameters’
The list of names of functions and the forms they will be translated to in ‘pb’ and other pattern macros.
See also: ‘define-pattern-function-translation’
List of the names of all defined pattern types.
The list of special keys for pbind that alters it during its initialization.
See also: ‘define-pbind-special-init-key’
The list of special keys for pbind that alter the outputs of the pbind.
See also: ‘define-pbind-special-process-key’
The list of special keys for pbind that causes the pbind to be replaced by another pattern during its initialization.
See also: ‘define-pbind-special-wrap-key’
The pdef dictionary hash table.
See also: ‘find-pdef’
Hash table mapping names and aliases to scale definition objects.
Hash table mapping names and aliases to tuning definition objects.
Define a conversion, storing function definition information so it can be used later to define "pseudo-ugens" for synthesis definitions in supported backends.
Define a special key with the key NAME for events (i.e. keys that take their values from other keys, or keys that have default values).
CASES is an alist of cases mapping event key names to forms. When ‘event-value’ is called on an event for the NAME key, then the event is tested for the keys of CASES in the order they’re listed. The associated form of the first key of CASES that exists in the event is evaluated to get the value of that call to ‘event-value’.
If no case is provided with a key that’s the same as NAME, one is automatically added at the start with a form that just returns the value of the event’s NAME key. If a case is provided with t as its key, that case is always run when found. This allows you to set a default value for the key if none of the other keys from CASES exist in the event.
REMOVE-KEYS is a list of keys to remove from the event when the NAME key is being set with ‘(setf event-value)’. If t (the default), all keys in CASES will be removed from the event.
DEFINE-METHODS, if true, will cause the macro to define methods for getting and setting the key in an event.
DOCUMENTATION is the documentation string for the function.
Example:
;; (define-event-special-key :amp ((:db (db-amp (raw-event-value event :db)))
;; (t 0.5))
;; :define-methods t)
This defines the amp key for events. Since the :amp key is implied, it doesn’t need to be specified in the CASES. Thus if the event already has an :amp key, its value will be used by default. If no :amp key exists in the event, then the :db FUNC is run if the :db key exists. If neither :amp nor :db exist in the event, then the t key is run, giving a default of 0.5.
Additionally, because :define-methods is true, we can also do the following:
;; (defparameter *foo* (event :amp 0.9))
;; (amp *foo*) ; => 0.9
;; (setf (amp *foo*) 0.7)
Define a translation from FUNCTION to PATTERN in ‘pb’.
Define a special key for pbind that alters the pbind during its initialization, either by embedding a plist into its pattern-pairs or in another way. These functions are called once, when the pbind is created, and must return a plist if the key should embed values into the pbind pairs, or NIL if it should not.
Define a special key for pbind that alters the pattern in a nonstandard way. These functions are called for each event created by the pbind and must return an event if the key should embed values into the event stream, or ‘eop’ if the pstream should end.
Define a special key for pbind that replaces the pbind with another pattern during the pbind’s initialization. Each encapsulation key is run once on the pbind after it has been initialized, altering the type of pattern returned if the return value of the function is non-NIL.
If EVENT has a ‘beat’ key, set it to VALUE; otherwise, set its ‘%beat’ "hidden key".
Convert a clock’s number of beats to a timestamp. The result is only guaranteed to be accurate if it’s greater than the clock’s beat-at-tempo slot.
Whether or not SYNTH in BACKEND has a gate control (i.e. whether it needs to be manually released or if it acts as a "one-shot").
Convert BOOLEAN to a MIDI value.
Examples:
;; ;; false/"off" values:
;; (boolean-to-midi nil) ;=> 0
;; (boolean-to-midi 0) ;=> 0
;; (boolean-to-midi 63) ;=> 63
;; ;; true/"on" values:
;; (boolean-to-midi t) ;=> 127
;; (boolean-to-midi 64) ;=> 64
;; (boolean-to-midi 127) ;=> 127
See also: ‘parse-boolean’
Whether PSTREAM can swap to its new definition, based on ‘end-quant’, ‘end-condition’, ‘ended-p’, and BEAT (the current beat of the clock).
Add ITEM (usually a ‘pstream’) to CLOCK’s tasks. Generally you don’t need to use this directly and would use ‘play’ instead.
See also: ‘clock-remove’, ‘play’
Remove all tasks from CLOCK.
See also: ‘clock-tasks’
Process EVENT on CLOCK. TASK is the associated task, and TYPE is the event type.
Remove TASK from CLOCK’s tasks. Generally you don’t need to use this directly and would use ‘stop’ or ‘end’ instead.
See also: ‘clock-add’, ‘stop’, ‘end’
Get a fresh version of LIST where each element is the sum of it and the previous elements.
Example:
;; (cumulative-list (list 1 2 3 4)) ;=> (1 3 6 10)
See also: ‘normalized-sum’
Decrease PATTERN’s KEY value.
See also: ‘remaining-p’
Get a list of backends that EVENT might be playable on, either via the event’s :backend key or via the ‘enabled-backends’.
Get an event like EVENT but with the :BEAT-AT-START and :TIMESTAMP-AT-START keys added for backends.
Get the output and backend names of the first enabled backend that supports RENDER-TYPE (i.e. :buffer, :file, :score, etc), or nil if none support it.
See also: ‘render’
Get the name and index of the symbol in SEQUENCE that represents the buffer argument. This is typically either :buffer or :bufnum.
Find an object identified by ID using ‘*dictionary-lookup-functions*’. Returns DEFAULT if no object was found, or signals an error if DEFAULT is the symbol :error.
See also: ‘find-pdef’
Unmap INPUT from the range specified by MAP to the range [0..1].
See also: ‘to-range’, ‘rerange’
Generate a list of aliases for NAME by mapping various combinations of ‘*abbreviations*’.
See also: ‘*abbreviations*’
Return a cons cell consisting of the input number and the offset its sharps/flats represent.
Get the index of the first element of LIST greater than N.
Get ‘*event*’ if it’s not nil, or get a fresh empty event.
Generate Lisp of a wrapper function named pFUNCTION whose definition is (pnary FUNCTION ...).
See also: ‘pnary’
Like ‘mapcar’, but the resulting list is the length of the longest input list instead of the shortest. Indexes into shorter lists are wrapped. Additional return values from the last call are passed through as additional values from this function.
Example:
;; (mapcar-longest #’+ (list 1) (list 2 3 4))
;; => (3 4 5)
See also: ‘multi-channel-funcall’
Test whether NUMBER is within RANGE (bipolar) of OF.
Examples:
;; (near-p 4 1 5) ; => t
;; (near-p 4 1) ; => nil
;; (near-p 0.5) ; => t
;; (near-p 0.5 0.6 1) ; => t
See also: ‘alexandria:clamp’, ‘wrap’, ‘nearest’
Get the element in LIST nearest to INPUT.
See also: ‘near-p’
Get a copy of LIST "normalized" so all of its numbers summed together equal SUM.
Examples:
;; (normalized-sum (list 1 1 1 1)) ;=> (1/4 1/4 1/4 1/4)
;; (normalized-sum (list 1 2 3) 2) ;=> (1/3 2/3 1)
See also: ‘cumulative-list’
Get the name of the pstream class for PATTERN.
Translate SEXP to the equivalent pattern as per ‘*pattern-function-translations*’, or pass it through unchanged if there is no translation.
See also: ‘pb-translate-body-functions’
Translate functions in BODY to their equivalent pattern as per ‘*pattern-function-translations*’.
See also: ‘pattern-translate-sexp’
Get a list of all the names in DICTIONARY that point to NAME.
See also: ‘all-pdef-names’, ‘all-pdefs’
Return a new copy of PLIST, but with its KEY set to VALUE.
Given INDEX, an absolute index into PSTREAM’s history, return the actual index into the current recorded history of the pstream.
See also: ‘pstream-history-advance-by’
Convert a history index (i.e. a positive number provided to ‘pstream-elt-future’) to the amount that the history must be advanced by.
If the provided index is before the earliest item in history, the result will be a negative number denoting how far beyond the earliest history the index is.
If the provided index is within the current history, the result will be zero.
If the provided index is in the future, the result will be a positive number denoting how far in the future it is.
See also: ‘pstream-elt-index-to-history-index’
Get the value of KEY in EVENT without running any conversion functions.
See also: ‘event-value’
Set the value of KEY to VALUE in EVENT without running any conversion functions.
See also: ‘raw-event-value’, ‘event-value’
True if PATTERN’s REMAINING-KEY slot value represents outputs "remaining" (see ‘value-remaining-p’). If PATTERN’s REMAINING-KEY slot is unbound or 0, and REPEATS-KEY is not nil, then it is automatically set to the ‘next’ of PATTERN’s REPEATS-KEY slot. Then if that new value is 0 or nil, remaining-p returns nil. Otherwise, :reset is returned as a generalized true value and to indicate that ‘next’ was called on PATTERN’s REPEATS-KEY slot.
See also: ‘value-remaining-p’, ‘decf-remaining’
Remap OUTPUT’s instrument key to arbitrary parameters specified in ‘*instrument-map*’. If OUTPUT is not an event or the instrument is not found in the map, it is passed through unchanged.
See also: ‘instrument-mapping’, ‘*instrument-map*’, ‘*post-pattern-output-processors*’
Loop through PATTERN’s slots and set the "parent" slot of any patterns to this pattern.
Given STRING, return a number representing how many semitones above or below its number it represents, by counting sharps (#) and flats (b).
Example:
;; (sharp-or-flat "#") ;=> 1
;; (sharp-or-flat "##") ;=> 2
;; (sharp-or-flat "b") ;=> -1
See also: ‘note-name-and-octave’, ‘index-and-offset’
Find the first instance of OLD in STRING and replace it with NEW. Return the new string, or if OLD was not found, return STRING unchanged. Returns the position that OLD was found as a second value, or nil if it was not found.
Get the list of nodes for TASK for the specified backend. If BACKEND is nil, get all of the resources for TASK regardless of backend.
Set the list of nodes for TASK for the specified backend. If BACKEND is nil, set the full backend-resources slot for the task.
Map INPUT from the range [0..1] to the range specified by MAP.
See also: ‘from-range’, ‘rerange’
Reader macro for ‘ptrack’ preprocessing.
True if VALUE represents that a pstream has outputs "remaining"; i.e. VALUE is a symbol (i.e. :inf), or a number greater than 0.
See also: ‘remaining-p’, ‘decf-remaining’
Get a list of the names of all defined synths (synthdefs, dsps, etc) for the specified backend.
See also: ‘backend-all-nodes’
Get a list of all active nodes for the specified backend.
See also: ‘backend-all-instruments’, ‘backend-node-p’, ‘backend-panic’
At TIME, set NODE’s parameters to PARAMS. If NODE is an instrument name, launch a node with those parameters at the specified time instead. This function should return the node object.
Convert OBJECT to a value that BACKEND can understand. For example, the SuperCollider backend requires that any ‘cl-collider::buffer’ objects are converted to their bufnum.
Generate a plist of parameters for INSTRUMENT based off of its controls, taking values from EVENT. Unlike ‘event-plist’, this function doesn’t include event keys that aren’t also one of the synth’s arguments.
Get the list of names of controls for INSTRUMENT in BACKEND.
True if OBJECT is a node for the specified backend.
See also: ‘backend-all-nodes’
"Panic" the backend, i.e. stop all of its nodes immediately.
See also: ‘backend-all-nodes’
Play ITEM on the sound server specified by BACKEND. TASK is the task that triggered ITEM to be played. Typically a backend should not need to define a specialized method for this generic if it already provides methods for the following:
- ‘backend-instrument-controls’
- ‘backend-node-p’
- ‘backend-timestamps-for-event’
- ‘backend-proxys-node’
- ‘backend-control-node-at’
It’s suggested to define methods for ‘backend-convert-object’ if the backend requires objects to be converted to another representation before being used as an instrument’s parameters. Additionally, methods for ‘play’, ‘launch’, ‘stop’, and ‘end’ may be convenient to define for the backend’s node class.
See also: ‘backend-task-removed’
Get the current node object on BACKEND for the proxy with the specified ID.
True if BACKEND should respond to EVENT.
Called when TASK is added to the clock so BACKEND can prepare any related state.
See also: ‘backend-task-removed’
Called when TASK is removed from the clock so BACKEND can free any associated nodes. Typically a backend shouldn’t need to define a method for this generic if it already defines methods for the events listed in the docstring for ‘backend-play-event’.
See also: ‘backend-play-event’
Set the backend’s tempo to NEW-TEMPO at the timestamp provided.
Get a list containing timestamps for the start and end of EVENT’s note, in the format that BACKEND expects for its scheduling function.
See also: ‘backend-control-node-at’
Get all the events from PSTREAM whose start beat are MIN or greater, and less than MAX.
Get the beat position of the ending of the last event in the ESEQ.
list)) ¶Returns the last output yielded by PSTREAM.
Example:
;; (defparameter *pstr* (as-pstream (pseq ’(1 2 3) 1)))
;; (next *pstr*) ;=> 1
;; (last-output *pstr*) ;=> 1
See also: ‘ended-p’
Get the mouse location information for DISPLAY-SERVER. Typically you should just call ‘mouse-location’ instead of using this directly.
eseq-pstream)) ¶Process a key/value pair for a pattern like ‘pbind’ or ‘pmeta’.
pstream-out-of-range)) ¶clock)) ¶Get the "real beat" of the clock; i.e. compute what the beat number should actually be at this instant in time (whereas the beat slot for the clock is quantized to the clock’s granularity).
Note that this function will likely be removed in the future with improvements to the clock, so you should expect to eventually have to update code depending on it.
See also: ‘beat’
condition.
:index
This slot is read-only.
A musical time-based clock defining a tempo and pulse that its tasks synchronize to.
The number of beats that have elapsed since the creation of the clock.
number
0
beat.
The tempo of the clock, in beats per second.
number
1
:tempo
This slot is read-only.
The default latency for events played on the clock; the number of seconds added onto the event’s scheduled time, in order to allow the backend to process it without being "late".
number
1/10
:latency
If T, always play events, even if their scheduled time has already passed. If NIL, silently skip these events. If :WARN, print a warning for each event skipped.
:play-expired-events
The restart to invoke when a condition occurs during task processing. If nil, the clock will not attempt to handle any conditions. If non-nil, all conditions signaled within a task will be caught and the specified restart will be invoked automatically to prevent the clock from pausing. Caught conditions will be printed as a warning and recorded with their stack trace in the clock’s caught-conditions slot.
symbol
:condition-handler
A list of conditions caught by the clock while processing tasks when its condition-handler is non-nil. Each entry in the list is a plist containing the the condition and the stack trace.
list
The lock on the caught-conditions slot to ensure it is thread-safe.
(bordeaux-threads:make-lock)
The list of tasks that are running on the clock. Use ‘play’, ‘stop’, etc to play and stop patterns (the "friendly" way to add or remove them from the clock), or ‘clock-add’ and ‘clock-remove’ to manually remove them directly.
list
The lock on the tasks to make the clock thread-safe.
(bordeaux-threads:make-recursive-lock)
The local-time timestamp when the tempo was last changed.
(local-time:now)
The number of beats on the clock when the tempo was last changed.
0
An item scheduled to be run on the clock.
The actual playing item that the task refers to. Typically this is a pstream or similar.
:item
Whether the task should loop. If left unbound, the task’s item’s loop-p slot is referred to instead.
:loop-p
The beat of the clock when the task started.
(or null number)
:start-beat
The clock that the task is running on.
cl-patterns::clock
:clock
Resources associated with this task that should be freed by it, i.e. nodes it triggered, buffers it loaded, etc.
:backend-resources
| Jump to: | %
(
A B C D E F G I K L M N O P Q R S T U V |
|---|
| Jump to: | %
(
A B C D E F G I K L M N O P Q R S T U V |
|---|
| Jump to: | %
*
A B C D E F G H I K L M N O P R S T V W |
|---|
| Jump to: | %
*
A B C D E F G H I K L M N O P R S T V W |
|---|
| Jump to: | B C E F I M P R S T U |
|---|
| Jump to: | B C E F I M P R S T U |
|---|