forked from tidalcycles/strudel
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge branch 'tidalcycles:main' into main
- Loading branch information
Showing
7 changed files
with
278 additions
and
234 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,214 @@ | ||
| /* | ||
| pick.mjs - methods that use one pattern to pick events from other patterns. | ||
| Copyright (C) 2024 Strudel contributors - see <https://github.com/tidalcycles/strudel/blob/main/packages/core/signal.mjs> | ||
| This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. | ||
| */ | ||
|
|
||
| import { Pattern, reify, silence, register } from './pattern.mjs'; | ||
|
|
||
| import { _mod, clamp, objectMap } from './util.mjs'; | ||
|
|
||
| const _pick = function (lookup, pat, modulo = true) { | ||
| const array = Array.isArray(lookup); | ||
| const len = Object.keys(lookup).length; | ||
|
|
||
| lookup = objectMap(lookup, reify); | ||
|
|
||
| if (len === 0) { | ||
| return silence; | ||
| } | ||
| return pat.fmap((i) => { | ||
| let key = i; | ||
| if (array) { | ||
| key = modulo ? Math.round(key) % len : clamp(Math.round(key), 0, lookup.length - 1); | ||
| } | ||
| return lookup[key]; | ||
| }); | ||
| }; | ||
|
|
||
| /** * Picks patterns (or plain values) either from a list (by index) or a lookup table (by name). | ||
| * Similar to `inhabit`, but maintains the structure of the original patterns. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| * @example | ||
| * note("<0 1 2!2 3>".pick(["g a", "e f", "f g f g" , "g c d"])) | ||
| * @example | ||
| * sound("<0 1 [2,0]>".pick(["bd sd", "cp cp", "hh hh"])) | ||
| * @example | ||
| * sound("<0!2 [0,1] 1>".pick(["bd(3,8)", "sd sd"])) | ||
| * @example | ||
| * s("<a!2 [a,b] b>".pick({a: "bd(3,8)", b: "sd sd"})) | ||
| */ | ||
|
|
||
| export const pick = function (lookup, pat) { | ||
| // backward compatibility - the args used to be flipped | ||
| if (Array.isArray(pat)) { | ||
| [pat, lookup] = [lookup, pat]; | ||
| } | ||
| return __pick(lookup, pat); | ||
| }; | ||
|
|
||
| const __pick = register('pick', function (lookup, pat) { | ||
| return _pick(lookup, pat, false).innerJoin(); | ||
| }); | ||
|
|
||
| /** * The same as `pick`, but if you pick a number greater than the size of the list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * For example, if you pick the fifth pattern of a list of three, you'll get the | ||
| * second one. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
|
|
||
| export const pickmod = register('pickmod', function (lookup, pat) { | ||
| return _pick(lookup, pat, true).innerJoin(); | ||
| }); | ||
|
|
||
| /** * pickF lets you use a pattern of numbers to pick which function to apply to another pattern. | ||
| * @param {Pattern} pat | ||
| * @param {Pattern} lookup a pattern of indices | ||
| * @param {function[]} funcs the array of functions from which to pull | ||
| * @returns {Pattern} | ||
| * @example | ||
| * s("bd [rim hh]").pickF("<0 1 2>", [rev,jux(rev),fast(2)]) | ||
| * @example | ||
| * note("<c2 d2>(3,8)").s("square") | ||
| * .pickF("<0 2> 1", [jux(rev),fast(2),x=>x.lpf(800)]) | ||
| */ | ||
| export const pickF = register('pickF', function (lookup, funcs, pat) { | ||
| return pat.apply(pick(lookup, funcs)); | ||
| }); | ||
|
|
||
| /** * The same as `pickF`, but if you pick a number greater than the size of the functions list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * @param {Pattern} pat | ||
| * @param {Pattern} lookup a pattern of indices | ||
| * @param {function[]} funcs the array of functions from which to pull | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickmodF = register('pickmodF', function (lookup, funcs, pat) { | ||
| return pat.apply(pickmod(lookup, funcs)); | ||
| }); | ||
|
|
||
| /** * Similar to `pick`, but it applies an outerJoin instead of an innerJoin. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickOut = register('pickOut', function (lookup, pat) { | ||
| return _pick(lookup, pat, false).outerJoin(); | ||
| }); | ||
|
|
||
| /** * The same as `pickOut`, but if you pick a number greater than the size of the list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickmodOut = register('pickmodOut', function (lookup, pat) { | ||
| return _pick(lookup, pat, true).outerJoin(); | ||
| }); | ||
|
|
||
| /** * Similar to `pick`, but the choosen pattern is restarted when its index is triggered. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickRestart = register('pickRestart', function (lookup, pat) { | ||
| return _pick(lookup, pat, false).restartJoin(); | ||
| }); | ||
|
|
||
| /** * The same as `pickRestart`, but if you pick a number greater than the size of the list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| * @example | ||
| * "<a@2 b@2 c@2 d@2>".pickRestart({ | ||
| a: n("0 1 2 0"), | ||
| b: n("2 3 4 ~"), | ||
| c: n("[4 5] [4 3] 2 0"), | ||
| d: n("0 -3 0 ~") | ||
| }).scale("C:major").s("piano") | ||
| */ | ||
| export const pickmodRestart = register('pickmodRestart', function (lookup, pat) { | ||
| return _pick(lookup, pat, true).restartJoin(); | ||
| }); | ||
|
|
||
| /** * Similar to `pick`, but the choosen pattern is reset when its index is triggered. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickReset = register('pickReset', function (lookup, pat) { | ||
| return _pick(lookup, pat, false).resetJoin(); | ||
| }); | ||
|
|
||
| /** * The same as `pickReset`, but if you pick a number greater than the size of the list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
| export const pickmodReset = register('pickmodReset', function (lookup, pat) { | ||
| return _pick(lookup, pat, true).resetJoin(); | ||
| }); | ||
|
|
||
| /** | ||
| /** * Picks patterns (or plain values) either from a list (by index) or a lookup table (by name). | ||
| * Similar to `pick`, but cycles are squeezed into the target ('inhabited') pattern. | ||
| * @name inhabit | ||
| * @synonyms pickSqueeze | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| * @example | ||
| * "<a b [a,b]>".inhabit({a: s("bd(3,8)"), | ||
| b: s("cp sd") | ||
| }) | ||
| * @example | ||
| * s("a@2 [a b] a".inhabit({a: "bd(3,8)", b: "sd sd"})).slow(4) | ||
| */ | ||
| export const { inhabit, pickSqueeze } = register(['inhabit', 'pickSqueeze'], function (lookup, pat) { | ||
| return _pick(lookup, pat, false).squeezeJoin(); | ||
| }); | ||
|
|
||
| /** * The same as `inhabit`, but if you pick a number greater than the size of the list, | ||
| * it wraps around, rather than sticking at the maximum value. | ||
| * For example, if you pick the fifth pattern of a list of three, you'll get the | ||
| * second one. | ||
| * @name inhabitmod | ||
| * @synonyms pickmodSqueeze | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| */ | ||
|
|
||
| export const { inhabitmod, pickmodSqueeze } = register(['inhabitmod', 'pickmodSqueeze'], function (lookup, pat) { | ||
| return _pick(lookup, pat, true).squeezeJoin(); | ||
| }); | ||
|
|
||
| /** | ||
| * Pick from the list of values (or patterns of values) via the index using the given | ||
| * pattern of integers. The selected pattern will be compressed to fit the duration of the selecting event | ||
| * @param {Pattern} pat | ||
| * @param {*} xs | ||
| * @returns {Pattern} | ||
| * @example | ||
| * note(squeeze("<0@2 [1!2] 2>", ["g a", "f g f g" , "g a c d"])) | ||
| */ | ||
|
|
||
| export const squeeze = (pat, xs) => { | ||
| xs = xs.map(reify); | ||
| if (xs.length == 0) { | ||
| return silence; | ||
| } | ||
| return pat | ||
| .fmap((i) => { | ||
| const key = _mod(Math.round(i), xs.length); | ||
| return xs[key]; | ||
| }) | ||
| .squeezeJoin(); | ||
| }; |
Oops, something went wrong.