takomusic 1.2.0

package/lib/rhythm.mf

@@ -0,0 +1,269 @@
+// Rhythm generation functions for TakoMusic
+// Algorithmic rhythm patterns and timing variations
+
+// euclidean - generate Euclidean rhythm pattern
+// Distributes pulses as evenly as possible across steps
+export proc euclidean(steps, pulses, dur, pitch) {
+  let pattern = [];
+  let bucket = 0;
+
+  for (i in 0..steps) {
+    bucket = bucket + pulses;
+    if (bucket >= steps) {
+      bucket = bucket - steps;
+      push(pattern, true);
+    } else {
+      push(pattern, false);
+    }
+  }
+
+  forEach(pattern, (hit) => {
+    if (hit) {
+      note(pitch, dur);
+    } else {
+      rest(dur);
+    }
+  });
+}
+
+// swing - apply swing feel to note sequence
+// amount: 0 = straight, 0.33 = triplet swing, 0.5 = extreme swing
+export proc swing(notes, dur, amount) {
+  forEach(notes, (n, i) => {
+    if (i % 2 == 0) {
+      const swingDur = dur * (1 + amount);
+      note(n, swingDur);
+    } else {
+      const swingDur = dur * (1 - amount);
+      note(n, swingDur);
+    }
+  });
+}
+
+// humanize - add random timing variations
+// Adds slight timing offsets to make rhythm feel more human
+export proc humanize(notes, dur, amount) {
+  forEach(notes, (n) => {
+    const offset = (random() - 0.5) * amount;
+    const offsetTicks = floor(offset * durToTicks(dur));
+    advanceTick(offsetTicks);
+    note(n, dur);
+  });
+}
+
+// shuffle - shuffle rhythm (dotted eighth + sixteenth)
+export proc shuffle(notes, dur) {
+  forEach(notes, (n, i) => {
+    if (i % 2 == 0) {
+      note(n, dur * 3/4);
+    } else {
+      note(n, dur * 1/4);
+    }
+  });
+}
+
+// clave - generate clave rhythm pattern
+export proc clave32(pitch, dur) {
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  rest(dur);
+}
+
+// clave23 - 2-3 clave (reverse)
+export proc clave23(pitch, dur) {
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  rest(dur);
+
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+  rest(dur);
+  note(pitch, dur);
+  rest(dur);
+}
+
+// polyrhythm - play two different rhythms simultaneously
+// Returns pattern array for manual track assignment
+export proc polyrhythmPattern(steps1, steps2, totalSteps) {
+  let pattern1 = [];
+  let pattern2 = [];
+
+  for (i in 0..totalSteps) {
+    push(pattern1, i % steps1 == 0);
+    push(pattern2, i % steps2 == 0);
+  }
+
+  return [pattern1, pattern2];
+}
+
+// Generate basic drum patterns
+export proc basicBeat(kickPitch, snarePitch, hatPitch, dur, bars) {
+  const steps = bars * 16;
+
+  for (i in 0..steps) {
+    const beat = i % 16;
+
+    // Kick on 1 and 3 (0, 8)
+    if (beat == 0 || beat == 8) {
+      drum(kickPitch, dur);
+    }
+
+    // Snare on 2 and 4 (4, 12)
+    if (beat == 4 || beat == 12) {
+      drum(snarePitch, dur);
+    }
+
+    // Hi-hat on every eighth note
+    if (beat % 2 == 0) {
+      drum(hatPitch, dur);
+    }
+
+    if (beat % 2 == 1) {
+      rest(dur);
+    }
+  }
+}
+
+// Apply groove template to notes
+// template: array of timing offsets (-1.0 to 1.0)
+export proc groove(notes, dur, template) {
+  for (i in 0..len(notes)) {
+    const templateIdx = i % len(template);
+    const offset = template[templateIdx];
+    const offsetTicks = floor(offset * durToTicks(dur) / 4);
+
+    if (offsetTicks > 0) {
+      advanceTick(offsetTicks);
+    }
+
+    note(notes[i], dur);
+
+    if (offsetTicks < 0) {
+      advanceTick(-offsetTicks);
+    }
+  }
+}
+
+// Common groove templates
+export proc swingGroove() {
+  return [0.0, 0.33, 0.0, 0.33];
+}
+
+export proc laidBackGroove() {
+  return [0.0, 0.1, 0.05, 0.15];
+}
+
+export proc pushGroove() {
+  return [0.0, -0.1, 0.0, -0.1];
+}
+
+// Rubato - expressive timing variation
+export proc rubato(notes, baseDur, variation) {
+  for (i in 0..len(notes)) {
+    const stretch = 1 + (random() - 0.5) * variation;
+    const dur = baseDur * stretch;
+    note(notes[i], dur);
+  }
+}
+
+// Accelerando - gradually speed up
+export proc accelerando(notes, startDur, endDur) {
+  const count = len(notes);
+  for (i in 0..count) {
+    const t = i / (count - 1);
+    const dur = startDur + (endDur - startDur) * t;
+    note(notes[i], dur);
+  }
+}
+
+// Ritardando - gradually slow down
+export proc ritardando(notes, startDur, endDur) {
+  accelerando(notes, startDur, endDur);
+}
+
+// Accelerando with tempo changes
+export proc accelerandoTempo(startBpm, endBpm, dur, steps) {
+  const ticks = durToTicks(dur);
+  const ticksPerStep = floor(ticks / steps);
+
+  for (i in 0..=steps) {
+    const t = i / steps;
+    const bpm = floor(startBpm + (endBpm - startBpm) * t);
+    atTick(i * ticksPerStep);
+    tempo(bpm);
+  }
+}
+
+// Ritardando with tempo changes
+export proc ritardandoTempo(startBpm, endBpm, dur, steps) {
+  accelerandoTempo(startBpm, endBpm, dur, steps);
+}
+
+// Fermata - pause/hold
+export proc fermata(pitch, baseDur, holdMultiplier) {
+  note(pitch, baseDur * holdMultiplier);
+}
+
+// Metric modulation helper
+// Returns the new tempo for metric modulation
+export proc metricModulation(currentBpm, oldSubdivision, newSubdivision) {
+  return floor(currentBpm * oldSubdivision / newSubdivision);
+}
+
+// Tuplet rhythm generator
+export proc tuplet(notes, totalDur, tupletRatio) {
+  const noteDur = totalDur / len(notes);
+  for (i in 0..len(notes)) {
+    note(notes[i], noteDur);
+  }
+}
+
+// Triplet
+export proc triplet(notes, baseDur) {
+  const tripletDur = baseDur * 2 / 3;
+  for (i in 0..len(notes)) {
+    note(notes[i], tripletDur);
+  }
+}
+
+// Syncopation pattern
+export proc syncopate(notes, dur) {
+  for (i in 0..len(notes)) {
+    if (i % 2 == 0) {
+      rest(dur / 2);
+      note(notes[i], dur / 2);
+    } else {
+      note(notes[i], dur);
+    }
+  }
+}
+
+// Hemiola - 3 against 2
+export proc hemiola(notes, dur) {
+  const hemiolaDur = dur * 2 / 3;
+  for (i in 0..len(notes)) {
+    note(notes[i], hemiolaDur);
+  }
+}

package/lib/theory.mf

@@ -0,0 +1,257 @@
+// Music theory helper functions for TakoMusic
+// Scales, chords, intervals, and harmonic functions
+
+// Chord construction - returns array of pitches
+
+export proc majorTriad(root) {
+  return [root, transpose(root, 4), transpose(root, 7)];
+}
+
+export proc minorTriad(root) {
+  return [root, transpose(root, 3), transpose(root, 7)];
+}
+
+export proc diminishedTriad(root) {
+  return [root, transpose(root, 3), transpose(root, 6)];
+}
+
+export proc augmentedTriad(root) {
+  return [root, transpose(root, 4), transpose(root, 8)];
+}
+
+export proc majorSeventh(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 11)];
+}
+
+export proc minorSeventh(root) {
+  return [root, transpose(root, 3), transpose(root, 7), transpose(root, 10)];
+}
+
+export proc dominantSeventh(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 10)];
+}
+
+export proc halfDiminishedSeventh(root) {
+  return [root, transpose(root, 3), transpose(root, 6), transpose(root, 10)];
+}
+
+export proc diminishedSeventh(root) {
+  return [root, transpose(root, 3), transpose(root, 6), transpose(root, 9)];
+}
+
+// Suspended chords
+export proc sus2(root) {
+  return [root, transpose(root, 2), transpose(root, 7)];
+}
+
+export proc sus4(root) {
+  return [root, transpose(root, 5), transpose(root, 7)];
+}
+
+// Add chords
+export proc add9(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 14)];
+}
+
+export proc minorAdd9(root) {
+  return [root, transpose(root, 3), transpose(root, 7), transpose(root, 14)];
+}
+
+// Extended chords
+export proc ninth(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 10), transpose(root, 14)];
+}
+
+export proc minorNinth(root) {
+  return [root, transpose(root, 3), transpose(root, 7), transpose(root, 10), transpose(root, 14)];
+}
+
+export proc majorNinth(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 11), transpose(root, 14)];
+}
+
+export proc eleventh(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 10), transpose(root, 14), transpose(root, 17)];
+}
+
+export proc thirteenth(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 10), transpose(root, 14), transpose(root, 21)];
+}
+
+// Sixth chords
+export proc sixth(root) {
+  return [root, transpose(root, 4), transpose(root, 7), transpose(root, 9)];
+}
+
+export proc minorSixth(root) {
+  return [root, transpose(root, 3), transpose(root, 7), transpose(root, 9)];
+}
+
+// Power chord (no third)
+export proc powerChord(root) {
+  return [root, transpose(root, 7)];
+}
+
+export proc powerChordOctave(root) {
+  return [root, transpose(root, 7), transpose(root, 12)];
+}
+
+// Scale generation - returns array of pitches for one octave
+
+export proc majorScale(root) {
+  const intervals = [0, 2, 4, 5, 7, 9, 11, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc minorScale(root) {
+  const intervals = [0, 2, 3, 5, 7, 8, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc harmonicMinor(root) {
+  const intervals = [0, 2, 3, 5, 7, 8, 11, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc melodicMinor(root) {
+  const intervals = [0, 2, 3, 5, 7, 9, 11, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc pentatonicMajor(root) {
+  const intervals = [0, 2, 4, 7, 9, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc pentatonicMinor(root) {
+  const intervals = [0, 3, 5, 7, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc bluesScale(root) {
+  const intervals = [0, 3, 5, 6, 7, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc dorianMode(root) {
+  const intervals = [0, 2, 3, 5, 7, 9, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc phrygianMode(root) {
+  const intervals = [0, 1, 3, 5, 7, 8, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc lydianMode(root) {
+  const intervals = [0, 2, 4, 6, 7, 9, 11, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc mixolydianMode(root) {
+  const intervals = [0, 2, 4, 5, 7, 9, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc aeolianMode(root) {
+  // Same as natural minor
+  return minorScale(root);
+}
+
+export proc locrianMode(root) {
+  const intervals = [0, 1, 3, 5, 6, 8, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc wholeToneScale(root) {
+  const intervals = [0, 2, 4, 6, 8, 10, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+export proc chromaticScale(root) {
+  const intervals = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
+  return map(intervals, (i) => transpose(root, i));
+}
+
+// Chord voicings
+
+export proc firstInversion(chordNotes) {
+  const root = chordNotes[0];
+  const rest = slice(chordNotes, 1, len(chordNotes));
+  return concat(rest, [transpose(root, 12)]);
+}
+
+export proc secondInversion(chordNotes) {
+  return firstInversion(firstInversion(chordNotes));
+}
+
+// Interval helpers
+
+export const UNISON = 0;
+export const MINOR_SECOND = 1;
+export const MAJOR_SECOND = 2;
+export const MINOR_THIRD = 3;
+export const MAJOR_THIRD = 4;
+export const PERFECT_FOURTH = 5;
+export const TRITONE = 6;
+export const PERFECT_FIFTH = 7;
+export const MINOR_SIXTH = 8;
+export const MAJOR_SIXTH = 9;
+export const MINOR_SEVENTH = 10;
+export const MAJOR_SEVENTH = 11;
+export const OCTAVE = 12;
+
+// Rhythm values (assuming 4/4 time signature)
+
+export const WHOLE = 1/1;
+export const HALF = 1/2;
+export const QUARTER = 1/4;
+export const EIGHTH = 1/8;
+export const SIXTEENTH = 1/16;
+export const THIRTY_SECOND = 1/32;
+
+export const DOTTED_HALF = 3/4;
+export const DOTTED_QUARTER = 3/8;
+export const DOTTED_EIGHTH = 3/16;
+
+// Helper to get scale degree
+export proc scaleDegree(scale, degree) {
+  const idx = (degree - 1) % len(scale);
+  return scale[idx];
+}
+
+// Generate chord progression using scale degrees
+export proc progression(scale, degrees, chordFunc) {
+  return map(degrees, (degree) => {
+    const root = scaleDegree(scale, degree);
+    return chordFunc(root);
+  });
+}
+
+// Common progressions
+export proc majorIIVI(root) {
+  const scale = majorScale(root);
+  return [
+    minorSeventh(scaleDegree(scale, 2)),
+    dominantSeventh(scaleDegree(scale, 5)),
+    majorSeventh(scaleDegree(scale, 1))
+  ];
+}
+
+export proc major145(root) {
+  const scale = majorScale(root);
+  return [
+    majorTriad(scaleDegree(scale, 1)),
+    majorTriad(scaleDegree(scale, 4)),
+    majorTriad(scaleDegree(scale, 5))
+  ];
+}
+
+export proc minor145(root) {
+  const scale = minorScale(root);
+  return [
+    minorTriad(scaleDegree(scale, 1)),
+    minorTriad(scaleDegree(scale, 4)),
+    minorTriad(scaleDegree(scale, 5))
+  ];
+}

package/lib/utils.mf

@@ -0,0 +1,140 @@
+// Utility functions for TakoMusic
+// General-purpose helper functions
+
+// Constrain value between min and max
+export proc clip(val, minVal, maxVal) {
+  return min(max(val, minVal), maxVal);
+}
+
+// Linear interpolation between a and b
+export proc lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+
+// Rescale value from input range to output range
+export proc rescale(val, inMin, inMax, outMin, outMax) {
+  const t = (val - inMin) / (inMax - inMin);
+  return lerp(outMin, outMax, t);
+}
+
+// Quantize value to nearest step
+export proc quantize(val, step) {
+  return floor(val / step) * step;
+}
+
+// Wrap value to range [min, max)
+export proc wrap(val, minVal, maxVal) {
+  const range = maxVal - minVal;
+  let result = val;
+  if (result < minVal) {
+    result = result + range * ceil((minVal - result) / range);
+  }
+  if (result >= maxVal) {
+    result = result - range * floor((result - minVal) / range);
+  }
+  return result;
+}
+
+// Sign function: returns -1, 0, or 1
+export proc sign(val) {
+  if (val > 0) { return 1; }
+  if (val < 0) { return -1; }
+  return 0;
+}
+
+// Randomize velocity with variation
+export proc randomizeVel(baseVel, variation) {
+  const offset = floor((random() - 0.5) * variation * 2);
+  return clip(baseVel + offset, 1, 127);
+}
+
+// Random choice from array
+export proc choice(arr) {
+  const idx = random(len(arr));
+  return arr[idx];
+}
+
+// Shuffle array (Fisher-Yates)
+export proc shuffle(arr) {
+  let result = copy(arr);
+  for (i in 0..len(result) - 1) {
+    const j = i + random(len(result) - i);
+    const temp = result[i];
+    result[i] = result[j];
+    result[j] = temp;
+  }
+  return result;
+}
+
+// Sum of array elements
+export proc sum(arr) {
+  return reduce(arr, (acc, x) => acc + x, 0);
+}
+
+// Average of array elements
+export proc average(arr) {
+  if (len(arr) == 0) { return 0; }
+  return sum(arr) / len(arr);
+}
+
+// Normalize array to range [0, 1]
+export proc normalize(arr) {
+  const minVal = reduce(arr, (a, b) => min(a, b), arr[0]);
+  const maxVal = reduce(arr, (a, b) => max(a, b), arr[0]);
+  const range = maxVal - minVal;
+  if (range == 0) { return fill(len(arr), 0.5); }
+  return map(arr, (x) => (x - minVal) / range);
+}
+
+// Zip two arrays into array of pairs
+export proc zip(arr1, arr2) {
+  const minLen = min(len(arr1), len(arr2));
+  let result = [];
+  for (i in 0..minLen) {
+    push(result, [arr1[i], arr2[i]]);
+  }
+  return result;
+}
+
+// Repeat pattern n times
+export proc repeatPattern(pattern, n) {
+  let result = [];
+  for (i in 0..n) {
+    for (j in 0..len(pattern)) {
+      push(result, pattern[j]);
+    }
+  }
+  return result;
+}
+
+// Rotate array by n positions
+export proc rotate(arr, n) {
+  const len = len(arr);
+  if (len == 0) { return []; }
+  const shift = n % len;
+  const idx = (len - shift) % len;
+  return concat(slice(arr, idx, len), slice(arr, 0, idx));
+}
+
+// Take first n elements
+export proc take(arr, n) {
+  return slice(arr, 0, min(n, len(arr)));
+}
+
+// Drop first n elements
+export proc drop(arr, n) {
+  return slice(arr, min(n, len(arr)), len(arr));
+}
+
+// Chunk array into groups of size n
+export proc chunk(arr, n) {
+  let result = [];
+  for (i in 0..len(arr)) {
+    if (i % n == 0) {
+      push(result, []);
+    }
+    const lastIdx = len(result) - 1;
+    push(result[lastIdx], arr[i]);
+  }
+  return result;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "takomusic",
+  "version": "1.2.0",
+  "description": "TakoMusic - A domain-specific language for music composition that generates VSQX, MusicXML, and MIDI",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mf": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "test:run": "vitest --run",
+    "lint": "eslint src",
+    "mf": "node dist/cli/index.js"
+  },
+  "keywords": [
+    "music",
+    "dsl",
+    "composition",
+    "midi",
+    "vsqx",
+    "musicxml",
+    "vocaloid",
+    "neutrino"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tako0614/takomusic"
+  },
+  "author": "",
+  "license": "AGPL-3.0",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "dependencies": {
+    "toml": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}