discombobulator 1.0.0

package/src/groupset.mjs

@@ -0,0 +1,259 @@
+// GroupSet.
+//
+// A group set is a set of groups, and allows patterns to be generated by 
+// permutating the group set with a pattern set.
+
+import util from "util";
+
+import { bitCount, factorial } from "./util.mjs";
+import { permutations, permutationIndexGenerator } from "./permute.mjs";
+
+import { Set } from "./set.mjs";
+import { Group } from "./group.mjs";
+import { Chord } from "./chord.mjs";
+import { Pattern } from "./pattern.mjs";
+import { PatternSet } from "./patternset.mjs";
+
+export class GroupSet extends Set {
+  // Permute.
+  //
+  // Class to generate the patterns formed by permutating a group set
+  // with a pattern or pattern set. A permute is effectively an abstract
+  // pattern set.
+  static Permute = class extends PatternSet {
+    #groupSet = undefined;
+    #patternSet = undefined;
+    #allowRepeats = false;
+
+    // Construct a Permute.
+    //
+    // groupSet     A GroupSet containing the groups to permute.
+    // patternSet   A Pattern or a PatternSet to permute the groups with.
+    constructor(groupSet, patternSet, options = {}) {
+      const defaults = { allowRepeats: false };
+      options = { ...defaults, ...options, isAbstract: true };
+
+      super(options);
+
+      let patterns;
+
+      if (patternSet instanceof Pattern) {
+        // Promote a single Pattern to a PatternSet.
+        patterns = new PatternSet();
+        patterns.add(patternSet);
+      } else if (patternSet instanceof PatternSet) {
+        patterns = patternSet;
+      } else {
+        throw new Error("Invalid argument - permute requires a Pattern or PatternSet");
+      }
+
+      this.#groupSet = groupSet;
+      this.#patternSet = patterns;
+      this.#allowRepeats = options.allowRepeats;
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Permute";
+    }
+
+    #describe() {
+      let description = "";
+
+      for (let pattern of this) {
+        description += util.inspect(pattern);
+      }
+
+      return description;
+    }
+
+    [util.inspect.custom](depth, opts) {
+      return `${this[Symbol.toStringTag]} {${this.#describe()}}`;
+    }
+
+    *[Symbol.iterator]() {
+      for (let group of this.groups) {
+        for (let pattern of this.patterns) {
+          let active = bitCount(group.group);
+
+          // Only do this pattern if it has enough chords to satisfy the group.
+          if (this.allowRepeats || group.length >= active) {
+            // Create each permutation of the current pattern for the current group.
+            for (let indices of permutationIndexGenerator(
+              active,
+              pattern.size,
+              this.allowRepeats
+            )) {
+              let resultPattern = new Pattern();
+
+              let groupBits = group.group;
+              let groupLength = group.length;
+              let index = 0;
+
+              while (groupLength-- > 0) {
+                // Add the selected chord if this position is active, otherwise add a rest chord.
+                resultPattern.add(groupBits & 1 ? pattern.elementAt(indices[index++]) : Chord.rest);
+                groupBits >>= 1;
+              }
+
+              yield resultPattern;
+            }
+          }
+        }
+      }
+    }
+
+    get groups() {
+      return this.#groupSet;
+    }
+
+    get patterns() {
+      return this.#patternSet;
+    }
+
+    get allowRepeats() {
+      return this.#allowRepeats;
+    }
+
+    // Return the number of patterns generated by permuting the
+    // given group with the given pattern.
+    #groupSize(group, pattern) {
+      let active = bitCount(group.group);
+
+      return this.allowRepeats
+        ? pattern.size ** active
+        : permutations(pattern.size, active);
+    }
+
+    get size() {
+      let size = 0;
+
+      for (let group of this.groups) {
+        for (let pattern of this.patterns) {
+          size += this.#groupSize(group, pattern);
+        }
+      }
+
+      return size;
+    }
+
+    elementAt(index = 0) {
+      for (let group of this.groups) {
+        for (let pattern of this.patterns) {
+          let groupSize = this.#groupSize(group, pattern);
+          let patternSize = pattern.size;
+          let indices = [];
+          let active = bitCount(group.group);
+          let modulus = 0;
+
+          if (index < groupSize) {
+            if (this.#allowRepeats) {
+              while (active-- > 0) {
+                modulus = (patternSize ** active);
+                indices.push(Math.floor(index / modulus));
+                index %= modulus;
+              }
+            } else {
+              let unusedIndices = [...Array(patternSize).keys()];
+              let modulus = factorial(unusedIndices.length);
+              let localIndex = 0;
+
+              while (active-- > 0) {
+                modulus = Math.floor(modulus / unusedIndices.length);
+                localIndex = Math.floor(index / modulus);
+                indices.push(unusedIndices[localIndex]);
+                unusedIndices.splice(localIndex, 1);
+                index %= modulus;
+              }
+            }
+
+            let resultPattern = new Pattern();
+
+            let groupBits = group.group;
+            let groupLength = group.length;
+            
+            index = 0;
+
+            while (groupLength-- > 0) {
+              // Add the selected chord if this position is active, otherwise add a rest chord.
+              resultPattern.add(groupBits & 1 ? pattern.elementAt(indices[index++]) : Chord.rest);
+              groupBits >>= 1;
+            }
+
+            return resultPattern;
+        }
+
+          index -= groupSize;
+        }
+      }
+
+      throw new Error("Invalid index");
+    }
+
+    #hasPattern(element, group, pattern) {
+      let groupLength = group.length;
+
+      if (element.size != groupLength) return false;
+
+      let groupBits = group.group;
+      let elementIndex = 0;
+      let patternIndex = -1;
+      let usedIndices = [];
+      let chord = undefined;
+
+      while (groupLength-- > 0) {
+        if (groupBits & 1) {
+          if (this.#allowRepeats) {
+            if (!pattern.has(element.elementAt(elementIndex))) return false;
+          } else {
+            chord = element.elementAt(elementIndex);
+
+            do {
+              patternIndex = pattern.indexOf(chord, patternIndex);
+            } while (usedIndices.includes(patternIndex));
+            
+            if (patternIndex < 0 || usedIndices.includes(patternIndex)) return false;
+
+            usedIndices.push(patternIndex);
+          }
+        } else if (!group.elementAt(index).isEqual(Chord.rest)) {
+          return false;
+        }
+
+        ++elementIndex;
+        groupBits >>= 1;
+      }
+
+      return true;
+    }
+
+    has(element) {
+      for (let group of this.groups) {
+        for (let pattern of this.patterns) {
+          if (this.#hasPattern(element, group, pattern)) return true;
+        }
+      }
+
+      return false;
+    }
+  };
+
+  constructor(options = {}) {
+    super(options);
+  }
+
+  get allowedElements() {
+    return [Group];
+  }
+
+  get [Symbol.toStringTag]() {
+    return "GroupSet";
+  }
+
+  // Permute a Pattern, or each Pattern of a PatternSet, with each
+  // Group in this GroupSet to produce a new PatternSet.
+  //
+  // other must be a Pattern or PatternSet.
+  permute(patterns, allowRepeats = false) {
+    return new GroupSet.Permute(this, patterns, allowRepeats);
+  }
+}

package/src/instrument.mjs

@@ -0,0 +1,105 @@
+// instrument.mjs
+//
+// An instrument is a playing surface that generates a note.
+
+import util from "util";
+
+import { Element } from "./element.mjs";
+
+export class Instrument extends Element {
+  #symbol = undefined; // Symbol representing the instrument.
+
+  constructor(id) {
+    super();
+
+    if (typeof id === 'string' || id instanceof String) {
+      this.#symbol = Symbol.for(id);
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return "Instrument";
+  }
+
+  [util.inspect.custom](depth, opts) {
+    return `Instrument {${
+      !!this.#symbol ? this.#symbol.toString() : "undefined"
+    }}`;
+  }
+
+  get symbol() { return this.#symbol; }
+
+  isEqual(other) {
+    return super.isEqual(other) && this.symbol == other.symbol;
+  }
+}
+
+// Library of defined instruments.
+export class Instruments {
+  static Bass1 = new Instrument("bass1");
+  static Bass1 = new Instrument("bass1");
+  static Bass2 = new Instrument("bass2");
+  static Casaba = new Instrument("casaba");
+  static China = new Instrument("china");
+  static Claves = new Instrument("claves");
+  static ClosedHighHat = new Instrument("closedhighhat");
+  static CowBell = new Instrument("cowbell");
+  static Crash = new Instrument("crash");
+  static CrashA = new Instrument("crasha");
+  static CrashB = new Instrument("crashb");
+  static Guiro = new Instrument("guiro");
+  static HalfOpenHighHat = new Instrument("halfopenhighhat");
+  static HandClap = new Instrument("handclap");
+  static HiBongo = new Instrument("hibongo");
+  static HiConga = new Instrument("hiconga");
+  static HighFloorTom = new Instrument("highfloortom");
+  static HighHat = new Instrument("highhat");
+  static HighHatPedal = new Instrument("highhatpedal");
+  static HighMidTom = new Instrument("highmidtom");
+  static HighTom = new Instrument("hightom");
+  static HighWoodBlock = new Instrument("highwoodblock");
+  static HiGogo = new Instrument("higogo");
+  static HiTimbale = new Instrument("hitimbale");
+  static LongGuiro = new Instrument("longguiro");
+  static LongWhistle = new Instrument("longwhistle");
+  static LowBongo = new Instrument("lowbongo");
+  static LowConga = new Instrument("lowconga");
+  static LowFloorTom = new Instrument("lowfloortom");
+  static LowGogo = new Instrument("lowgogo");
+  static LowMidTom = new Instrument("lowmidtom");
+  static LowTimbale = new Instrument("lowtimbale");
+  static LowTom = new Instrument("lowtom");
+  static LowWoodBlock = new Instrument("lowwoodblock");
+  static Maracas = new Instrument("maracas");
+  static MuteCuica = new Instrument("mutecuica");
+  static MuteHiBongo = new Instrument("mutehibongo");
+  static MuteHiConga = new Instrument("mutehiconga");
+  static MuteHiTimbale = new Instrument("mutehitimbale");
+  static MuteLowBongo = new Instrument("mutelowbongo");
+  static MuteLowConga = new Instrument("mutelowconga");
+  static MuteLowTimbale = new Instrument("mutelowtimbale");
+  static MuteTriangle = new Instrument("mutetriangle");
+  static OpenCuica = new Instrument("opencuica");
+  static OpenHiBongo = new Instrument("openhibongo");
+  static OpenHiConga = new Instrument("openhiconga");
+  static OpenHighHat = new Instrument("openhighhat");
+  static OpenHiTimbale = new Instrument("openhitimbale");
+  static OpenLowBongo = new Instrument("openlowbongo");
+  static OpenLowConga = new Instrument("openlowconga");
+  static OpenLowTimbale = new Instrument("openlowtimbale");
+  static OpenTriangle = new Instrument("opentriangle");
+  static Ride = new Instrument("ride");
+  static RideA = new Instrument("ridea");
+  static RideB = new Instrument("rideb");
+  static RideBell = new Instrument("ridebell");
+  static ShortGuiro = new Instrument("shortguiro");
+  static ShortWhistle = new Instrument("shortwhistle");
+  static SideStick = new Instrument("lowgogo");
+  static Snare = new Instrument("snare");
+  static Splash = new Instrument("splash");
+  static Tambourine = new Instrument("tambourine");
+  static TamTam = new Instrument("tamtam");
+  static Triangle = new Instrument("triangle");
+  static VibraSlap = new Instrument("vibraslap");
+  static WoodBlock = new Instrument("woodblock");
+}

package/src/instrumentset.mjs

@@ -0,0 +1,20 @@
+// InstrumentSet
+//
+// A set of instruments.
+
+import { Set } from './set.mjs'
+import { Instrument } from './instrument.mjs'
+
+export class InstrumentSet extends Set {
+    constructor(options = {}) {
+        super(options)
+    }
+
+    get allowedElements() {
+        return [ Instrument ];
+    }
+
+    get [Symbol.toStringTag]() {
+        return "InstrumentSet";
+    }
+}

package/src/irregulargroupset.mjs

@@ -0,0 +1,224 @@
+// IrregularGroupGenerator is a Group generator that generates groups of lengths
+// determined by a range (as with RegularGroupSet), except that the number of active
+// chords in a group varies based on another range, and all permutation of such groups
+// are generated.
+
+import util from "util";
+
+import { bitCount } from "./util.mjs";
+import { combinations, ithBinaryCombination } from "./permute.mjs";
+
+import { Group } from "./group.mjs";
+import { RegularGroupSet } from "./regulargroupset.mjs";
+
+export class IrregularGroupSet extends RegularGroupSet {
+  #min = 1;
+  #max = undefined;
+  #stepping = 1;
+  #reverseMax = false;
+
+  // Construct an IregularGroupSet with args:
+  //  start       The minimum number of chords in the generated groups. Default is 1.
+  //  end         The maximum number of chords in the generated groups. Must be >= start.
+  //              If undefined then uses start. Default is undefined.
+  //  step        Step rate to increase group size by. Must be > 0. Default is 1.
+  //
+  //  min         The minimum number of active chords in a generated group. Must be >= 1. Default is 1.
+  //  max         The maximum number of active chords in a generated group. Must be >= min.
+  //              If undefined then uses the group size and reverseMax is ignored. Default is undefined.
+  //  stepping    Step rate to increase number of active chords by. Must be > 0. Default is 1.
+  //  reverseMax  If true, max is calculated as MAX(min, group_size - max) instead of being taken literally.
+  //              eg. if min=1, max=2 and the current group size is 5, then max = MAX(1, 5-2) = 3, and
+  //                  active chords will range in number from 1 to 3.
+  //              Defauls it false.
+  constructor(options) {
+    super(options);
+
+    const defaults = { min: 1, max: undefined, stepping: 1, reverseMax: false };
+    options = { ...defaults, ...options };
+    let { min, max, stepping, reverseMax } = options;
+
+    if (min < 1)
+      throw new Error(
+        `Invalid minimum number of active chords - must be 1 or greater (${this.start})`
+      );
+    if (max !== undefined && max < min)
+      throw new Error(
+        `Invalid maximum number of chords - must be no less than min (${min})`
+      );
+    if (1 > stepping || stepping > Group.MAX_LENGTH)
+      throw new Error(
+        `Invalid step size - must be from 1 to ${Group.MAX_LENGTH - 1}`
+      );
+
+    this.#min = min;
+    this.#max = max;
+    this.#stepping = stepping;
+    this.#reverseMax = reverseMax;
+  }
+
+  // Overide Set.clone.
+  clone() {
+    let clone = new this.constructor({
+      start: this.start,
+      end: this.end,
+      step: this.step,
+      max: this.#max,
+      min: this.#min,
+      stepping: this.#stepping,
+      reverseMax: this.#reverseMax,
+    });
+
+    return clone;
+  }
+
+  get min() {
+    return this.#min;
+  }
+
+  get max() {
+    return this.#max;
+  }
+
+  get stepping() {
+    return this.#stepping;
+  }
+
+  get reverseMax() {
+    return this.#reverseMax;
+  }
+
+  get [Symbol.toStringTag]() {
+    return "IrregularGroupSet";
+  }
+
+  #actualMax(length) {
+    return Math.max(
+      this.min,
+      this.max === undefined
+        ? length
+        : this.reverseMax
+        ? length - this.max
+        : Math.min(length, this.max)
+    );
+  }
+
+  [util.inspect.custom](depth, opts) {
+    let groups = "";
+
+    for (const group of this) {
+      groups += (groups.length == 0 ? "" : ", ") + util.inspect(group);
+    }
+
+    return `${this[Symbol.toStringTag]} {[${groups}]}`;
+  }
+
+  *[Symbol.iterator]() {
+    // For each group size...
+    for (let length = this.start; length <= this.end; length += this.step) {
+      // Permutate the active number of chords...
+      const max = this.#actualMax(length);
+
+      for (let active = this.min; active <= max; active += this.stepping) {
+        // Calculate each permutation of <active> chords in a group size of <length>.
+        let index = 0;
+        let group = 0;
+
+        while ((group = ithBinaryCombination(length, active, index++))) {
+          yield new Group(group, length);
+        }
+      }
+    }
+  }
+
+  elementAt(index = 0) {
+    if (index >= 0 && index < this.size) {
+      for (let length = this.start; length <= this.end; length += this.step) {
+        const max = this.#actualMax(length);
+
+        for (let active = this.min; active <= max; active += this.stepping) {
+          const combos = combinations(length, active);
+
+          if (index < combos) {
+            return new Group(
+              ithBinaryCombination(length, active, index),
+              length
+            );
+          } else {
+            index -= combos;
+          }
+        }
+      }
+
+      return new Group(ithBinaryCombination(length, active, index++), length);
+    }
+
+    throw new Error("Invalid index");
+  }
+
+  get size() {
+    let size = 0;
+
+    for (let length = this.start; length <= this.end; length += this.step) {
+      // Permutate the active number of chords...
+      const max = this.#actualMax(length);
+
+      for (let active = this.min; active <= max; active += this.stepping) {
+        size += combinations(length, active);
+      }
+    }
+
+    return size;
+  }
+
+  // Returns whether the given element exists in this Set.
+  has(element) {
+    if (element === undefined || !(element instanceof Group)) {
+      throw new Error("Argument must be a Group");
+    }
+
+    const length = element.length;
+
+    // Fail if length is outside of bounds or not included by the step.
+    if (
+      length < this.start 
+      || this.end < length 
+      || ((length-1) % this.step) !== 0
+    ) { 
+      return false;
+    }
+
+    let group = element.group;
+    let active = bitCount(group);
+    const max = this.#actualMax(length);
+
+    // Fail if active bits is outside of bounds or not included by the stepping.
+    if (
+      active < this.min 
+      || max < active
+      || ((active-1) % this.stepping) !== 0
+    ) 
+    {
+      return false;
+    }
+
+    return true;
+    // let inactive = length - active;
+
+    // while (active + inactive > 0) {
+    //   if (group & 1) {
+    //     if (active-- === 0) {
+    //       return false;
+    //     }
+    //   } else {
+    //     if (inactive-- === 0) {
+    //       return false;
+    //     }
+    //   }
+
+    //   group >>= 1;
+    // }
+
+    // return group === 0;
+  }
+}