elias/strudel-docker
1
0
Fork 0
mirror of https://github.com/eliasstepanik/strudel-docker.git synced 2026-01-22 02:58:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

now running smooth without memoization

Browse Source
This commit is contained in:
Felix Roos 2022-03-19 12:03:26 +01:00
parent 77fafd40fb
commit 61e81a4e60
8 changed files with 24 additions and 924 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

908
fraction.js
View File

@ -1,908 +0,0 @@
/**
* @license Fraction.js v4.1.2 23/05/2021
* https://www.xarg.org/2014/03/rational-numbers-in-javascript/
*
* Copyright (c) 2021, Robert Eisele (robert@xarg.org)
* Dual licensed under the MIT or GPL Version 2 licenses.
**/
/**
*
* This class offers the possibility to calculate fractions.
* You can pass a fraction in different formats. Either as array, as double, as string or as an integer.
*
* Array/Object form
* [ 0 => <nominator>, 1 => <denominator> ]
* [ n => <nominator>, d => <denominator> ]
*
* Integer form
* - Single integer value
*
* Double form
* - Single double value
*
* String form
* 123.456 - a simple double
* 123/456 - a string fraction
* 123.'456' - a double with repeating decimal places
* 123.(456) - synonym
* 123.45'6' - a double with repeating last place
* 123.45(6) - synonym
*
* Example:
*
* var f = new Fraction("9.4'31'");
* f.mul([-4, 3]).div(4.9);
*
*/
const memo = {};
let root = {};
"use strict";
// Maximum search depth for cyclic rational numbers. 2000 should be more than enough.
// Example: 1/7 = 0.(142857) has 6 repeating decimal places.
// If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits
var MAX_CYCLE_LEN = 2000;
// Parsed data to avoid calling "new" all the time
var P = {
"s": 1,
"n": 0,
"d": 1
};
function createError(name) {
function errorConstructor() {
var temp = Error.apply(this, arguments);
temp['name'] = this['name'] = name;
this['stack'] = temp['stack'];
this['message'] = temp['message'];
}
/**
* Error constructor
*
* @constructor
*/
function IntermediateInheritor() { }
IntermediateInheritor.prototype = Error.prototype;
errorConstructor.prototype = new IntermediateInheritor();
return errorConstructor;
}
var DivisionByZero = Fraction['DivisionByZero'] = createError('DivisionByZero');
var InvalidParameter = Fraction['InvalidParameter'] = createError('InvalidParameter');
function assign(n, s) {
if (isNaN(n = parseInt(n, 10))) {
throwInvalidParam();
}
return n * s;
}
function throwInvalidParam() {
throw new InvalidParameter();
}
function factorize(num) {
var factors = {};
var n = num;
var i = 2;
var s = 4;
while (s <= n) {
while (n % i === 0) {
n /= i;
factors[i] = (factors[i] || 0) + 1;
}
s += 1 + 2 * i++;
}
if (n !== num) {
if (n > 1)
factors[n] = (factors[n] || 0) + 1;
} else {
factors[num] = (factors[num] || 0) + 1;
}
return factors;
}
var parse = function(p1, p2) {
var n = 0, d = 1, s = 1;
var v = 0, w = 0, x = 0, y = 1, z = 1;
var A = 0, B = 1;
var C = 1, D = 1;
var N = 10000000;
var M;
if (p1 === undefined || p1 === null) {
/* void */
} else if (p2 !== undefined) {
n = p1;
d = p2;
s = n * d;
} else
switch (typeof p1) {
case "object":
{
if ("d" in p1 && "n" in p1) {
n = p1["n"];
d = p1["d"];
if ("s" in p1)
n *= p1["s"];
} else if (0 in p1) {
n = p1[0];
if (1 in p1)
d = p1[1];
} else {
throwInvalidParam();
}
s = n * d;
break;
}
case "number":
{
if (p1 < 0) {
s = p1;
p1 = -p1;
}
if (p1 % 1 === 0) {
n = p1;
} else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow
if (p1 >= 1) {
z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10));
p1 /= z;
}
const key = p1+'#'+p2
const memoized = memo[key]
if(memoized) {
s = memoized.s;
n = memoized.n;
d = memoized.d;
break;
}
// Using Farey Sequences
// http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/
while (B <= N && D <= N) {
M = (A + C) / (B + D);
if (p1 === M) {
if (B + D <= N) {
n = A + C;
d = B + D;
} else if (D > B) {
n = C;
d = D;
} else {
n = A;
d = B;
}
break;
} else {
if (p1 > M) {
A += C;
B += D;
} else {
C += A;
D += B;
}
if (B > N) {
n = C;
d = D;
} else {
n = A;
d = B;
}
}
}
n *= z;
} else if (isNaN(p1) || isNaN(p2)) {
d = n = NaN;
}
break;
}
case "string":
{
B = p1.match(/\d+|./g);
if (B === null)
throwInvalidParam();
if (B[A] === '-') {// Check for minus sign at the beginning
s = -1;
A++;
} else if (B[A] === '+') {// Check for plus sign at the beginning
A++;
}
if (B.length === A + 1) { // Check if it's just a simple number "1234"
w = assign(B[A++], s);
} else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number
if (B[A] !== '.') { // Handle 0.5 and .5
v = assign(B[A++], s);
}
A++;
// Check for decimal places
if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") {
w = assign(B[A], s);
y = Math.pow(10, B[A].length);
A++;
}
// Check for repeating places
if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") {
x = assign(B[A + 1], s);
z = Math.pow(10, B[A + 1].length) - 1;
A += 3;
}
} else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456"
w = assign(B[A], s);
y = assign(B[A + 2], 1);
A += 3;
} else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2"
v = assign(B[A], s);
w = assign(B[A + 2], s);
y = assign(B[A + 4], 1);
A += 5;
}
if (B.length <= A) { // Check for more tokens on the stack
d = y * z;
s = /* void */
n = x + d * v + z * w;
break;
}
/* Fall through on error */
}
default:
throwInvalidParam();
}
if (d === 0) {
throw new DivisionByZero();
}
P["s"] = s < 0 ? -1 : 1;
P["n"] = Math.abs(n);
P["d"] = Math.abs(d);
memo[p1+'#'+p2] = {s:P["s"],n:P["n"],d:P["d"]};
};
function modpow(b, e, m) {
var r = 1;
for (; e > 0; b = (b * b) % m, e >>= 1) {
if (e & 1) {
r = (r * b) % m;
}
}
return r;
}
function cycleLen(n, d) {
for (; d % 2 === 0;
d /= 2) {
}
for (; d % 5 === 0;
d /= 5) {
}
if (d === 1) // Catch non-cyclic numbers
return 0;
// If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem:
// 10^(d-1) % d == 1
// However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone,
// as we want to translate the numbers to strings.
var rem = 10 % d;
var t = 1;
for (; rem !== 1; t++) {
rem = rem * 10 % d;
if (t > MAX_CYCLE_LEN)
return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1`
}
return t;
}
function cycleStart(n, d, len) {
var rem1 = 1;
var rem2 = modpow(10, len, d);
for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE)
// Solve 10^s == 10^(s+t) (mod d)
if (rem1 === rem2)
return t;
rem1 = rem1 * 10 % d;
rem2 = rem2 * 10 % d;
}
return 0;
}
function gcd(a, b) {
if (!a)
return b;
if (!b)
return a;
while (1) {
a %= b;
if (!a)
return b;
b %= a;
if (!b)
return a;
}
};
/**
* Module constructor
*
* @constructor
* @param {number|Fraction=} a
* @param {number=} b
*/
function Fraction(a, b) {
if (!(this instanceof Fraction)) {
return new Fraction(a, b);
}
parse(a, b);
a = gcd(P["d"], P["n"]); // Abuse variable a
this["s"] = P["s"];
this["n"] = P["n"] / a;
this["d"] = P["d"] / a;
}
Fraction.prototype = {
"s": 1,
"n": 0,
"d": 1,
/**
* Calculates the absolute value
*
* Ex: new Fraction(-4).abs() => 4
**/
"abs": function() {
return new Fraction(this["n"], this["d"]);
},
/**
* Inverts the sign of the current fraction
*
* Ex: new Fraction(-4).neg() => 4
**/
"neg": function() {
return new Fraction(-this["s"] * this["n"], this["d"]);
},
/**
* Adds two rational numbers
*
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
**/
"add": function(a, b) {
parse(a, b);
return new Fraction(
this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
this["d"] * P["d"]
);
},
/**
* Subtracts two rational numbers
*
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
**/
"sub": function(a, b) {
parse(a, b);
return new Fraction(
this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
this["d"] * P["d"]
);
},
/**
* Multiplies two rational numbers
*
* Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
**/
"mul": function(a, b) {
parse(a, b);
return new Fraction(
this["s"] * P["s"] * this["n"] * P["n"],
this["d"] * P["d"]
);
},
/**
* Divides two rational numbers
*
* Ex: new Fraction("-17.(345)").inverse().div(3)
**/
"div": function(a, b) {
parse(a, b);
return new Fraction(
this["s"] * P["s"] * this["n"] * P["d"],
this["d"] * P["n"]
);
},
/**
* Clones the actual object
*
* Ex: new Fraction("-17.(345)").clone()
**/
"clone": function() {
return new Fraction(this);
},
/**
* Calculates the modulo of two rational numbers - a more precise fmod
*
* Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
**/
"mod": function(a, b) {
if (isNaN(this['n']) || isNaN(this['d'])) {
return new Fraction(NaN);
}
if (a === undefined) {
return new Fraction(this["s"] * this["n"] % this["d"], 1);
}
parse(a, b);
if (0 === P["n"] && 0 === this["d"]) {
Fraction(0, 0); // Throw DivisionByZero
}
/*
* First silly attempt, kinda slow
*
return that["sub"]({
"n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)),
"d": num["d"],
"s": this["s"]
});*/
/*
* New attempt: a1 / b1 = a2 / b2 * q + r
* => b2 * a1 = a2 * b1 * q + b1 * b2 * r
* => (b2 * a1 % a2 * b1) / (b1 * b2)
*/
return new Fraction(
this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
P["d"] * this["d"]
);
},
/**
* Calculates the fractional gcd of two rational numbers
*
* Ex: new Fraction(5,8).gcd(3,7) => 1/56
*/
"gcd": function(a, b) {
parse(a, b);
// gcd(a / b, c / d) = gcd(a, c) / lcm(b, d)
return new Fraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
},
/**
* Calculates the fractional lcm of two rational numbers
*
* Ex: new Fraction(5,8).lcm(3,7) => 15
*/
"lcm": function(a, b) {
parse(a, b);
// lcm(a / b, c / d) = lcm(a, c) / gcd(b, d)
if (P["n"] === 0 && this["n"] === 0) {
return new Fraction;
}
return new Fraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
},
/**
* Calculates the ceil of a rational number
*
* Ex: new Fraction('4.(3)').ceil() => (5 / 1)
**/
"ceil": function(places) {
places = Math.pow(10, places || 0);
if (isNaN(this["n"]) || isNaN(this["d"])) {
return new Fraction(NaN);
}
return new Fraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places);
},
/**
* Calculates the floor of a rational number
*
* Ex: new Fraction('4.(3)').floor() => (4 / 1)
**/
"floor": function(places) {
places = Math.pow(10, places || 0);
if (isNaN(this["n"]) || isNaN(this["d"])) {
return new Fraction(NaN);
}
return new Fraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places);
},
/**
* Rounds a rational numbers
*
* Ex: new Fraction('4.(3)').round() => (4 / 1)
**/
"round": function(places) {
places = Math.pow(10, places || 0);
if (isNaN(this["n"]) || isNaN(this["d"])) {
return new Fraction(NaN);
}
return new Fraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
},
/**
* Gets the inverse of the fraction, means numerator and denominator are exchanged
*
* Ex: new Fraction([-3, 4]).inverse() => -4 / 3
**/
"inverse": function() {
return new Fraction(this["s"] * this["d"], this["n"]);
},
/**
* Calculates the fraction to some rational exponent, if possible
*
* Ex: new Fraction(-1,2).pow(-3) => -8
*/
"pow": function(a, b) {
parse(a, b);
// Trivial case when exp is an integer
if (P['d'] === 1) {
if (P['s'] < 0) {
return new Fraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n']));
} else {
return new Fraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n']));
}
}
// Negative roots become complex
// (-a/b)^(c/d) = x
// <=> (-1)^(c/d) * (a/b)^(c/d) = x
// <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x # rotate 1 by 180°
// <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index )
// From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case.
if (this['s'] < 0) return null;
// Now prime factor n and d
var N = factorize(this['n']);
var D = factorize(this['d']);
// Exponentiate and take root for n and d individually
var n = 1;
var d = 1;
for (var k in N) {
if (k === '1') continue;
if (k === '0') {
n = 0;
break;
}
N[k]*= P['n'];
if (N[k] % P['d'] === 0) {
N[k]/= P['d'];
} else return null;
n*= Math.pow(k, N[k]);
}
for (var k in D) {
if (k === '1') continue;
D[k]*= P['n'];
if (D[k] % P['d'] === 0) {
D[k]/= P['d'];
} else return null;
d*= Math.pow(k, D[k]);
}
if (P['s'] < 0) {
return new Fraction(d, n);
}
return new Fraction(n, d);
},
/**
* Check if two rational numbers are the same
*
* Ex: new Fraction(19.6).equals([98, 5]);
**/
"equals": function(a, b) {
parse(a, b);
return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0
},
/**
* Check if two rational numbers are the same
*
* Ex: new Fraction(19.6).equals([98, 5]);
**/
"compare": function(a, b) {
parse(a, b);
var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]);
return (0 < t) - (t < 0);
},
"simplify": function(eps) {
// First naive implementation, needs improvement
if (isNaN(this['n']) || isNaN(this['d'])) {
return this;
}
var cont = this['abs']()['toContinued']();
eps = eps || 0.001;
function rec(a) {
if (a.length === 1)
return new Fraction(a[0]);
return rec(a.slice(1))['inverse']()['add'](a[0]);
}
for (var i = 0; i < cont.length; i++) {
var tmp = rec(cont.slice(0, i + 1));
if (tmp['sub'](this['abs']())['abs']().valueOf() < eps) {
return tmp['mul'](this['s']);
}
}
return this;
},
/**
* Check if two rational numbers are divisible
*
* Ex: new Fraction(19.6).divisible(1.5);
*/
"divisible": function(a, b) {
parse(a, b);
return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"])));
},
/**
* Returns a decimal representation of the fraction
*
* Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
**/
'valueOf': function() {
return this["s"] * this["n"] / this["d"];
},
/**
* Returns a string-fraction representation of a Fraction object
*
* Ex: new Fraction("1.'3'").toFraction() => "4 1/3"
**/
'toFraction': function(excludeWhole) {
var whole, str = "";
var n = this["n"];
var d = this["d"];
if (this["s"] < 0) {
str += '-';
}
if (d === 1) {
str += n;
} else {
if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
str += whole;
str += " ";
n %= d;
}
str += n;
str += '/';
str += d;
}
return str;
},
/**
* Returns a latex representation of a Fraction object
*
* Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
**/
'toLatex': function(excludeWhole) {
var whole, str = "";
var n = this["n"];
var d = this["d"];
if (this["s"] < 0) {
str += '-';
}
if (d === 1) {
str += n;
} else {
if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
str += whole;
n %= d;
}
str += "\\frac{";
str += n;
str += '}{';
str += d;
str += '}';
}
return str;
},
/**
* Returns an array of continued fraction elements
*
* Ex: new Fraction("7/8").toContinued() => [0,1,7]
*/
'toContinued': function() {
var t;
var a = this['n'];
var b = this['d'];
var res = [];
if (isNaN(a) || isNaN(b)) {
return res;
}
do {
res.push(Math.floor(a / b));
t = a % b;
a = b;
b = t;
} while (a !== 1);
return res;
},
/**
* Creates a string representation of a fraction with all digits
*
* Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
**/
'toString': function(dec) {
var g;
var N = this["n"];
var D = this["d"];
if (isNaN(N) || isNaN(D)) {
return "NaN";
}
dec = dec || 15; // 15 = decimal places when no repetation
var cycLen = cycleLen(N, D); // Cycle length
var cycOff = cycleStart(N, D, cycLen); // Cycle start
var str = this['s'] === -1 ? "-" : "";
str += N / D | 0;
N %= D;
N *= 10;
if (N)
str += ".";
if (cycLen) {
for (var i = cycOff; i--;) {
str += N / D | 0;
N %= D;
N *= 10;
}
str += "(";
for (var i = cycLen; i--;) {
str += N / D | 0;
N %= D;
N *= 10;
}
str += ")";
} else {
for (var i = dec; N && i--;) {
str += N / D | 0;
N %= D;
N *= 10;
}
}
return str;
}
};
if (typeof define === "function" && define["amd"]) {
define([], function() {
return Fraction;
});
} else if (typeof exports === "object") {
Object.defineProperty(Fraction, "__esModule", { 'value': true });
Fraction['default'] = Fraction;
Fraction['Fraction'] = Fraction;
module['exports'] = Fraction;
} else {
root['Fraction'] = Fraction;
}
export default Fraction;

2
repl/src/draw.mjs
View File

@ -31,7 +31,7 @@ Pattern.prototype.draw = function (callback, cycleSpan, lookaheadCycles = 1) {
const end = (currentCycle + lookaheadCycles) * cycleSpan; const end = (currentCycle + lookaheadCycles) * cycleSpan;
events = this._asNumber(true) // true = silent error events = this._asNumber(true) // true = silent error
.query(new State(new TimeSpan(begin, end))) .query(new State(new TimeSpan(begin, end)))
.filter((event) => event.part.begin.valueOf() === event.whole.begin.valueOf()); .filter((event) => event.part.begin.equals(event.whole.begin));
} }
} }
callback(ctx, events, t, cycleSpan, time); callback(ctx, events, t, cycleSpan, time);

3
repl/src/euclid.mjs
View File

@ -1,6 +1,7 @@
import { Pattern, timeCat } from '../../strudel.mjs'; import { Pattern, timeCat } from '../../strudel.mjs';
import bjork from 'bjork'; import bjork from 'bjork';
import { rotate } from '../../util.mjs'; import { rotate } from '../../util.mjs';
import Fraction from 'fraction.js';
const euclid = (pulses, steps, rotation = 0) => { const euclid = (pulses, steps, rotation = 0) => {
const b = bjork(steps, pulses); const b = bjork(steps, pulses);
@ -22,7 +23,7 @@ Pattern.prototype.euclidLegato = function (pulses, steps, rotation = 0) {
.split('1') .split('1')
.slice(1) .slice(1)
.map((s) => [s.length + 1, true]); .map((s) => [s.length + 1, true]);
return this.struct(timeCat(...gapless)).late(firstOne / steps); return this.struct(timeCat(...gapless)).late(Fraction(firstOne).div(steps));
}; };
export default euclid; export default euclid;

7
repl/src/parse.ts
View File

@ -12,7 +12,7 @@ const applyOptions = (parent: any) => (pat: any, i: number) => {
if (operator) { if (operator) {
switch (operator.type_) { switch (operator.type_) {
case 'stretch': case 'stretch':
const speed = new Fraction(operator.arguments_.amount).inverse().valueOf(); const speed = new Fraction(operator.arguments_.amount).inverse();
return reify(pat).fast(speed); return reify(pat).fast(speed);
case 'bjorklund': case 'bjorklund':
return pat.euclid(operator.arguments_.pulse, operator.arguments_.step, operator.arguments_.rotation); return pat.euclid(operator.arguments_.pulse, operator.arguments_.step, operator.arguments_.rotation);
@ -56,7 +56,9 @@ function resolveReplications(ast) {
options_: { options_: {
operator: { operator: {
type_: 'stretch', type_: 'stretch',
arguments_: { amount: String(new Fraction(replicate).inverse().valueOf()) }, // valueOf should be ok here, as we turn it into a string
// fraction.js doc: "If you want to keep the number as it is, convert it to a string, as the string parser will not perform any further observations"
arguments_: { amount: String(new Fraction(replicate).inverse().valueOf()) },
}, },
}, },
}, },
@ -103,6 +105,7 @@ export function patternifyAST(ast: any): any {
return ast.source_; return ast.source_;
} }
const { start, end } = ast.location_; const { start, end } = ast.location_;
// should we really parse as number here? strings wont be fareyed...
const value = !isNaN(Number(ast.source_)) ? Number(ast.source_) : ast.source_; const value = !isNaN(Number(ast.source_)) ? Number(ast.source_) : ast.source_;
// return ast.source_; // return ast.source_;
// the following line expects the shapeshifter to wrap this in withLocationOffset // the following line expects the shapeshifter to wrap this in withLocationOffset

2
repl/src/static.mjs
View File

@ -24,7 +24,7 @@ async function playStatic(code) {
start = performance.now(); start = performance.now();
const events = pat const events = pat
?.query(new State(new TimeSpan(0, seconds))) ?.query(new State(new TimeSpan(0, seconds)))
?.filter((event) => event.part.begin.valueOf() === event.whole.begin.valueOf()) ?.filter((event) => event.part.begin.equals(event.whole.begin))
?.map((event) => ({ ?.map((event) => ({
time: event.whole.begin.valueOf(), time: event.whole.begin.valueOf(),
duration: event.whole.end.sub(event.whole.begin).valueOf(), duration: event.whole.end.sub(event.whole.begin).valueOf(),

1
repl/src/types.d.ts vendored
View File

@ -7,6 +7,7 @@ export declare interface Fraction {
s: number; s: number;
sub: (f: Fraction) => Fraction; sub: (f: Fraction) => Fraction;
sam: () => Fraction; sam: () => Fraction;
equals: (f: Fraction) => boolean;
} }
export declare interface TimeSpan { export declare interface TimeSpan {
constructor: any; //? constructor: any; //?

2
repl/src/useCycle.ts
View File

@ -40,7 +40,7 @@ function useCycle(props: UseCycleProps) {
// schedule events for next cycle // schedule events for next cycle
events events
?.filter((event) => event.part.begin.valueOf() === event.whole.begin.valueOf()) ?.filter((event) => event.part.begin.equals(event.whole.begin))
.forEach((event) => { .forEach((event) => {
Tone.getTransport().schedule((time) => { Tone.getTransport().schedule((time) => {
const toneEvent = { const toneEvent = {

23
strudel.mjs
View File

@ -1,4 +1,4 @@
import Fraction from './fraction.js' import Fraction from 'fraction.js'
import { compose } from 'ramda'; // will remove this as soon as compose is implemented here import { compose } from 'ramda'; // will remove this as soon as compose is implemented here
import { isNote, toMidi } from './util.mjs'; import { isNote, toMidi } from './util.mjs';
@ -32,7 +32,7 @@ export function curry(func, overload) {
// Returns the start of the cycle. // Returns the start of the cycle.
Fraction.prototype.sam = function() { Fraction.prototype.sam = function() {
return this.floor() return this.floor();
} }
// Returns the start of the next cycle. // Returns the start of the next cycle.
@ -510,13 +510,16 @@ class Pattern {
_bindWhole(choose_whole, func) { _bindWhole(choose_whole, func) {
const pat_val = this const pat_val = this
const query = function(state) { const query = function(state) {
const withWhole = function(a, b) { const withWhole = function (a, b) {
return new Hap(choose_whole(a.whole, b.whole), b.part, b.value, { return new Hap(
...a.context, choose_whole(a.whole, b.whole),
...b.context, b.part,
b.value,
Object.assign({}, a.context, b.context, {
locations: (a.context.locations || []).concat(b.context.locations || []), locations: (a.context.locations || []).concat(b.context.locations || []),
}); })
} );
};
const match = function (a) { const match = function (a) {
return func(a.value).query(state.setSpan(a.part)).map(b => withWhole(a, b)) return func(a.value).query(state.setSpan(a.part)).map(b => withWhole(a, b))
} }
@ -798,8 +801,8 @@ const _fromBipolar = pat => pat.fmap(x => (x + 1) / 2)
export const sine2 = signal(t => Math.sin(Math.PI * 2 * t)) export const sine2 = signal(t => Math.sin(Math.PI * 2 * t))
export const sine = _fromBipolar(sine2) export const sine = _fromBipolar(sine2)
export const cosine2 = sine2._early(0.25) export const cosine2 = sine2._early(Fraction(1).div(4))
export const cosine = sine._early(0.25) export const cosine = sine._early(Fraction(1).div(4))
export const saw = signal(t => t % 1) export const saw = signal(t => t % 1)
export const saw2 = _toBipolar(saw) export const saw2 = _toBipolar(saw)