From fc542861e8259ebdaa9205952ffa3841950bac36 Mon Sep 17 00:00:00 2001 From: alex Date: Wed, 26 Jan 2022 12:39:12 +0000 Subject: [PATCH 1/3] fix fastcat --- index.html | 3 ++- js/strudel.mjs | 46 ++++++++++++++++++++++++++++++++----------- test/pattern.test.mjs | 20 ++++++++++++++++++- 3 files changed, 56 insertions(+), 13 deletions(-) diff --git a/index.html b/index.html index 1baabcb6..6bf19cf2 100644 --- a/index.html +++ b/index.html @@ -1,5 +1,6 @@ - + Bingo diff --git a/js/strudel.mjs b/js/strudel.mjs index 91c4f2e9..250a99ca 100644 --- a/js/strudel.mjs +++ b/js/strudel.mjs @@ -191,16 +191,18 @@ class Pattern { this.query = query } - splitQueries() { + _splitQueries() { // Splits queries at cycle boundaries. This makes some calculations // easier to express, as all events are then constrained to happen within // a cycle. - var query = function(span) { - return flatten(span.spanCycles.map(subspan => this.query(subspan))) + var pat = this + var q = function(span) { + return flatten(span.spanCycles.map(subspan => pat.query(subspan))) } - return new Pattern(query) + return new Pattern(q) } + withQuerySpan(func) { return new Pattern(span => this.query(func(span))) } @@ -235,7 +237,7 @@ class Pattern { } _filterEvents(event_test) { - return new Pattern(span => this.query(span).filter(event_tespanCyclesst)) + return new Pattern(span => this.query(span).filter(event_test)) } _filterValues(value_test) { @@ -424,11 +426,11 @@ class Pattern { when(binary_pat, func) { //binary_pat = sequence(binary_pat) - var true_pat = binary_pat._filter_values(id) - var false_pat = binary_pat._filter_values(val => !val) - var with_pat = true_pat.fmap(_ => y => y).app_right(func(this)) - var without_pat = false_pat.fmap(_ => y => y).app_right(this) - return stack(with_pat, without_pat) + var true_pat = binary_pat._filterValues(id) + var false_pat = binary_pat._filterValues(val => !val) + var with_pat = true_pat.fmap(_ => y => y).appRight(func(this)) + var without_pat = false_pat.fmap(_ => y => y).appRight(this) + return stack([with_pat, without_pat]) } // def off(self, time_pat, func): @@ -495,5 +497,27 @@ function stack(pats) { return new Pattern(query) } -export {Fraction, TimeSpan, Hap, Pattern, pure, stack} +function slowcat(pats) { + // Concatenation: combines a list of patterns, switching between them + // successively, one per cycle. + // (currently behaves slightly differently from Tidal) + //var pats = pats.map(reify) + var query = function(span) { + var pat = pats[Math.floor(span.begin) % pats.length] + return pat.query(span) + } + return new Pattern(query)._splitQueries() +} + +function fastcat(pats) { + // Concatenation: as with slowcat, but squashes a cycle from each + // pattern into one cycle + return slowcat(pats)._fast(pats.length) +} + +function cat(pats) { + return fastcat(pats) +} + +export {Fraction, TimeSpan, Hap, Pattern, pure, stack, slowcat, fastcat, cat} diff --git a/test/pattern.test.mjs b/test/pattern.test.mjs index 34628c7e..f6e0d545 100644 --- a/test/pattern.test.mjs +++ b/test/pattern.test.mjs @@ -2,7 +2,7 @@ import Fraction from 'fraction.js' import { strict as assert } from 'assert'; -import {TimeSpan, Hap, Pattern, pure, stack} from "../js/strudel.mjs"; +import {TimeSpan, Hap, Pattern, pure, stack, fastcat, slowcat, cat} from "../js/strudel.mjs"; describe('TimeSpan', function() { describe('equals()', function() { @@ -90,5 +90,23 @@ describe('Pattern', function() { it('Makes things slower', function () { assert.deepStrictEqual(pure("a")._slow(2).firstCycle[0], new Hap(new TimeSpan(Fraction(0),Fraction(2)), new TimeSpan(Fraction(0), Fraction(1)), "a")) }) + }) + describe('_filterValues()', function () { + it('Filters true', function () { + assert.equal(pure(true)._filterValues(x => x).firstCycle.length, 1) + }) + }) + describe('when()', function () { + it('Always faster', function () { + assert.equal(pure("a").when(pure(true), x => x._fast(2)).firstCycle.length, 2) + }) + it('Never faster', function () { + assert.equal(pure("a").when(pure(false), x => x._fast(2)).firstCycle.length, 1) + }) + }) + describe('fastcat()', function () { + it('Can concatenate two things', function () { + assert.deepStrictEqual(fastcat([pure("a"), pure("b")]).firstCycle.map(x => x.value), ["a", "b"]) + }) }) }) \ No newline at end of file From c924057c56994f6738a6732ba782dfd2f6e5b969 Mon Sep 17 00:00:00 2001 From: alex Date: Wed, 26 Jan 2022 12:44:15 +0000 Subject: [PATCH 2/3] slowcat test --- test/pattern.test.mjs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/pattern.test.mjs b/test/pattern.test.mjs index f6e0d545..ddb2e981 100644 --- a/test/pattern.test.mjs +++ b/test/pattern.test.mjs @@ -109,4 +109,10 @@ describe('Pattern', function() { assert.deepStrictEqual(fastcat([pure("a"), pure("b")]).firstCycle.map(x => x.value), ["a", "b"]) }) }) + describe('slowcat()', function () { + it('Can concatenate things slowly', function () { + assert.deepStrictEqual(slowcat([pure("a"), pure("b")]).firstCycle.map(x => x.value), ["a"]) + assert.deepStrictEqual(slowcat([pure("a"), pure("b")])._early(1).firstCycle.map(x => x.value), ["b"]) + }) + }) }) \ No newline at end of file From e53ec44d986518fe1e9826b88b0bb23b41c9b17e Mon Sep 17 00:00:00 2001 From: alex Date: Wed, 26 Jan 2022 12:48:32 +0000 Subject: [PATCH 3/3] off --- js/strudel.mjs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/js/strudel.mjs b/js/strudel.mjs index 250a99ca..9c3be950 100644 --- a/js/strudel.mjs +++ b/js/strudel.mjs @@ -433,6 +433,10 @@ class Pattern { return stack([with_pat, without_pat]) } + off(time_pat, func) { + return stack([this, func(this._early(time_pat))]) + } + // def off(self, time_pat, func): // return stack(self, self.early(time_pat))