takomusic 1.2.0

package/lib/notation.mf

@@ -0,0 +1,224 @@
+// Notation helpers for TakoMusic
+// Musical notation utilities and conversions
+
+import { clip } from "./utils.mf";
+
+// Convert dynamic marking to velocity
+export proc dynamicToVel(marking) {
+  if (marking == "pppp") { return 16; }
+  if (marking == "ppp") { return 33; }
+  if (marking == "pp") { return 49; }
+  if (marking == "p") { return 64; }
+  if (marking == "mp") { return 80; }
+  if (marking == "mf") { return 96; }
+  if (marking == "f") { return 112; }
+  if (marking == "ff") { return 120; }
+  if (marking == "fff") { return 124; }
+  if (marking == "ffff") { return 127; }
+  return 96; // default mf
+}
+
+// Convert tempo marking to BPM
+export proc tempoToBpm(marking) {
+  if (marking == "grave") { return 40; }
+  if (marking == "largo") { return 50; }
+  if (marking == "lento") { return 60; }
+  if (marking == "adagio") { return 70; }
+  if (marking == "andante") { return 90; }
+  if (marking == "moderato") { return 110; }
+  if (marking == "allegretto") { return 115; }
+  if (marking == "allegro") { return 130; }
+  if (marking == "vivace") { return 150; }
+  if (marking == "presto") { return 180; }
+  if (marking == "prestissimo") { return 200; }
+  return 120; // default
+}
+
+// Play triplet feel
+export proc tripletFeel(notes, baseDur) {
+  const longDur = baseDur * 2/3;
+  const shortDur = baseDur * 1/3;
+
+  for (i in 0..len(notes)) {
+    if (i % 2 == 0) {
+      note(notes[i], longDur);
+    } else {
+      note(notes[i], shortDur);
+    }
+  }
+}
+
+// Play dotted rhythm
+export proc dottedRhythm(notes, baseDur) {
+  const longDur = baseDur * 3/4;
+  const shortDur = baseDur * 1/4;
+
+  for (i in 0..len(notes)) {
+    if (i % 2 == 0) {
+      note(notes[i], longDur);
+    } else {
+      note(notes[i], shortDur);
+    }
+  }
+}
+
+// Generate scale in specific octave range
+export proc scaleInRange(scaleFunc, root, octaves) {
+  let result = [];
+  for (oct in 0..octaves) {
+    const octaveRoot = transpose(root, oct * 12);
+    const scale = scaleFunc(octaveRoot);
+    for (i in 0..len(scale) - 1) {
+      push(result, scale[i]);
+    }
+  }
+  return result;
+}
+
+// Create melody from scale degrees
+export proc melodyFromDegrees(scale, degrees, dur) {
+  for (i in 0..len(degrees)) {
+    const degree = degrees[i];
+    if (degree == 0) {
+      rest(dur);
+    } else {
+      const idx = (degree - 1) % len(scale);
+      const octave = floor((degree - 1) / len(scale));
+      const pitch = transpose(scale[idx], octave * 12);
+      note(pitch, dur);
+    }
+  }
+}
+
+// Harmonize melody with interval
+export proc harmonize(melody, interval, dur) {
+  for (i in 0..len(melody)) {
+    const pitches = [melody[i], transpose(melody[i], interval)];
+    chord(pitches, dur);
+  }
+}
+
+// Create countermelody (simple inversion)
+export proc invertMelody(melody, axis) {
+  let result = [];
+  const axisMidi = pitchMidi(axis);
+
+  for (i in 0..len(melody)) {
+    const pitchMidi = pitchMidi(melody[i]);
+    const distance = pitchMidi - axisMidi;
+    const inverted = axisMidi - distance;
+    push(result, midiPitch(clip(inverted, 0, 127)));
+  }
+
+  return result;
+}
+
+// Retrograde (reverse) melody
+export proc retrograde(melody) {
+  let result = [];
+  for (i in 0..len(melody)) {
+    const idx = len(melody) - 1 - i;
+    push(result, melody[idx]);
+  }
+  return result;
+}
+
+// Rhythmic augmentation (make durations longer)
+export proc augment(rhythms, factor) {
+  let result = [];
+  for (i in 0..len(rhythms)) {
+    push(result, rhythms[i] * factor);
+  }
+  return result;
+}
+
+// Rhythmic diminution (make durations shorter)
+export proc diminish(rhythms, factor) {
+  return augment(rhythms, 1 / factor);
+}
+
+// Generate pickup notes (anacrusis)
+export proc pickupNotes(notes, totalDur, noteDur) {
+  const pickupDur = len(notes) * noteDur;
+  const waitDur = totalDur - pickupDur;
+
+  if (waitDur > 0) {
+    rest(waitDur);
+  }
+
+  for (i in 0..len(notes)) {
+    note(notes[i], noteDur);
+  }
+}
+
+// Bass line from chord progression
+export proc bassLine(chords, dur) {
+  for (i in 0..len(chords)) {
+    const root = chords[i][0];
+    const bassNote = transpose(root, -12);
+    note(bassNote, dur);
+  }
+}
+
+// Walking bass pattern
+export proc walkingBass(chord, nextChord, dur) {
+  const root = chord[0];
+  const third = chord[1];
+  const fifth = chord[2];
+  const nextRoot = nextChord[0];
+
+  // Basic walking pattern: root, third, fifth, approach
+  note(transpose(root, -12), dur);
+  note(transpose(third, -12), dur);
+  note(transpose(fifth, -12), dur);
+
+  // Approach note (half step below next root)
+  const approach = transpose(nextRoot, -13);
+  note(approach, dur);
+}
+
+// Alberti bass pattern
+export proc albertiBass(chord, repetitions, dur) {
+  const pattern = [0, 2, 1, 2]; // root, fifth, third, fifth
+
+  for (rep in 0..repetitions) {
+    for (i in 0..len(pattern)) {
+      const idx = pattern[i];
+      if (idx < len(chord)) {
+        note(transpose(chord[idx], -12), dur);
+      }
+    }
+  }
+}
+
+// Convert note name to pitch
+export proc noteNameToPitch(name, octave) {
+  let semitone = 0;
+
+  const noteLetter = charAt(name, 0);
+  if (noteLetter == "C") { semitone = 0; }
+  if (noteLetter == "D") { semitone = 2; }
+  if (noteLetter == "E") { semitone = 4; }
+  if (noteLetter == "F") { semitone = 5; }
+  if (noteLetter == "G") { semitone = 7; }
+  if (noteLetter == "A") { semitone = 9; }
+  if (noteLetter == "B") { semitone = 11; }
+
+  // Check for accidental
+  if (len(name) > 1) {
+    const accidental = charAt(name, 1);
+    if (accidental == "#") { semitone = semitone + 1; }
+    if (accidental == "b") { semitone = semitone - 1; }
+  }
+
+  const midiNum = 12 + octave * 12 + semitone;
+  return midiPitch(clip(midiNum, 0, 127));
+}
+
+// Tuplet helper (generic n-tuplet)
+export proc playTuplet(notes, totalDur, ratio) {
+  const noteDur = totalDur / len(notes) * ratio;
+  for (i in 0..len(notes)) {
+    note(notes[i], noteDur);
+  }
+}

package/lib/ornaments.mf

@@ -0,0 +1,98 @@
+// Ornament functions for TakoMusic
+// Musical decorations and embellishments
+
+// trill - rapid alternation between two adjacent notes
+export proc trill(pitch, dur, interval) {
+  const count = 8;
+  const subDur = dur / count;
+
+  for (i in 0..count) {
+    if (i % 2 == 0) {
+      note(pitch, subDur);
+    } else {
+      note(transpose(pitch, interval), subDur);
+    }
+  }
+}
+
+// mordent - single alternation with adjacent note
+export proc mordent(pitch, dur, interval) {
+  const mainDur = dur * 3/4;
+  const ornDur = dur * 1/4;
+
+  note(transpose(pitch, interval), ornDur);
+  note(pitch, mainDur);
+}
+
+// arpeggio - play chord notes in sequence
+export proc arpeggio(pitches, dur) {
+  const subDur = dur / len(pitches);
+  forEach(pitches, (p) => note(p, subDur));
+}
+
+// tremolo - rapid repetition of single note
+export proc tremolo(pitch, dur, rate) {
+  const count = floor(rate);
+  const subDur = dur / count;
+
+  for (i in 0..count) {
+    note(pitch, subDur);
+  }
+}
+
+// turn - ornamental figure going above and below the main note
+export proc turn(pitch, dur) {
+  const subDur = dur / 4;
+
+  note(transpose(pitch, 2), subDur);   // upper neighbor
+  note(pitch, subDur);                 // main note
+  note(transpose(pitch, -2), subDur);  // lower neighbor
+  note(pitch, subDur);                 // main note
+}
+
+// gruppetto - Italian turn
+export proc gruppetto(pitch, dur) {
+  const subDur = dur / 5;
+
+  note(pitch, subDur);
+  note(transpose(pitch, 2), subDur);
+  note(pitch, subDur);
+  note(transpose(pitch, -2), subDur);
+  note(pitch, subDur);
+}
+
+// appoggiatura - grace note that takes time from main note
+export proc appoggiatura(gracePitch, mainPitch, totalDur) {
+  const graceDur = totalDur / 4;
+  const mainDur = totalDur * 3/4;
+
+  note(gracePitch, graceDur);
+  note(mainPitch, mainDur);
+}
+
+// acciaccatura - very short grace note (crushed note)
+export proc acciaccatura(gracePitch, mainPitch, totalDur) {
+  const graceDur = totalDur / 8;
+  const mainDur = totalDur * 7/8;
+
+  note(gracePitch, graceDur);
+  note(mainPitch, mainDur);
+}
+
+// glissando - slide between two pitches
+export proc glissando(startPitch, endPitch, dur) {
+  const startMidi = pitchMidi(startPitch);
+  const endMidi = pitchMidi(endPitch);
+  const steps = abs(endMidi - startMidi);
+  const subDur = dur / (steps + 1);
+
+  if (startMidi < endMidi) {
+    for (i in 0..=steps) {
+      note(midiPitch(startMidi + i), subDur);
+    }
+  } else {
+    for (i in 0..=steps) {
+      note(midiPitch(startMidi - i), subDur);
+    }
+  }
+}

package/lib/patterns.mf

@@ -0,0 +1,170 @@
+// Advanced pattern generation for TakoMusic
+// Algorithmic composition and generative music
+
+import { choice, shuffle, clip, wrap, rotate } from "./utils.mf";
+
+// Random walk melody generator
+export proc randomWalk(startPitch, steps, maxStep) {
+  let melody = [];
+  let current = startPitch;
+
+  for (i in 0..steps) {
+    push(melody, current);
+    const step = random(-maxStep, maxStep + 1);
+    current = transpose(current, step);
+    current = transpose(C0, clip(pitchMidi(current), 0, 127));
+  }
+
+  return melody;
+}
+
+// Pentatonic random walk
+export proc pentatonicWalk(root, steps) {
+  const scale = [0, 2, 4, 7, 9, 12];
+  let melody = [];
+  let idx = 0;
+
+  for (i in 0..steps) {
+    const offset = scale[idx % len(scale)];
+    const octave = floor(idx / len(scale));
+    push(melody, transpose(root, offset + octave * 12));
+
+    const step = random(-2, 3);
+    idx = clip(idx + step, 0, len(scale) * 3 - 1);
+  }
+
+  return melody;
+}
+
+// Fractal melody generator (simple self-similarity)
+export proc fractalMelody(pattern, depth) {
+  if (depth == 0) {
+    return pattern;
+  }
+
+  let result = [];
+  for (i in 0..len(pattern)) {
+    const pitch = pattern[i];
+    push(result, pitch);
+
+    // Insert transposed version of pattern at smaller scale
+    const subPattern = fractalMelody(pattern, depth - 1);
+    for (j in 0..len(subPattern)) {
+      push(result, transpose(subPattern[j], 7));
+    }
+  }
+
+  return result;
+}
+
+// Probability-based rhythm pattern
+export proc probabilityRhythm(steps, probability) {
+  let pattern = [];
+  for (i in 0..steps) {
+    push(pattern, random() < probability);
+  }
+  return pattern;
+}
+
+// Density-based rhythm (gradually increase/decrease density)
+export proc densityRhythm(steps, startProb, endProb) {
+  let pattern = [];
+  for (i in 0..steps) {
+    const t = i / (steps - 1);
+    const prob = startProb + (endProb - startProb) * t;
+    push(pattern, random() < prob);
+  }
+  return pattern;
+}
+
+// Polyrhythmic pattern generator
+export proc polyrhythm(ratio1, ratio2, cycles) {
+  const totalSteps = ratio1 * ratio2;
+  let pattern1 = [];
+  let pattern2 = [];
+
+  for (i in 0..totalSteps * cycles) {
+    push(pattern1, i % ratio1 == 0);
+    push(pattern2, i % ratio2 == 0);
+  }
+
+  return [pattern1, pattern2];
+}
+
+// Phasing pattern (Steve Reich style)
+export proc phasePattern(pattern, phaseShift, repetitions) {
+  let result = [];
+
+  for (rep in 0..repetitions) {
+    const shift = floor(rep * phaseShift) % len(pattern);
+    const rotated = rotate(pattern, shift);
+    for (i in 0..len(rotated)) {
+      push(result, rotated[i]);
+    }
+  }
+
+  return result;
+}
+
+// Markov chain melody (simple 2-state)
+export proc markovMelody(notes, transitionProb, length, startIdx) {
+  let melody = [];
+  let currentIdx = startIdx;
+
+  for (i in 0..length) {
+    push(melody, notes[currentIdx]);
+
+    // Simple transition: stay or move
+    if (random() < transitionProb) {
+      currentIdx = (currentIdx + 1) % len(notes);
+    }
+  }
+
+  return melody;
+}
+
+// Arpeggiate chord with pattern
+export proc arpeggiate(chord, pattern, dur) {
+  for (i in 0..len(pattern)) {
+    const idx = pattern[i];
+    if (idx >= 0 && idx < len(chord)) {
+      note(chord[idx], dur);
+    } else {
+      rest(dur);
+    }
+  }
+}
+
+// Generate arpeggio pattern (up, down, up-down, random)
+export proc arpeggioPattern(chordSize, style, length) {
+  let pattern = [];
+
+  for (i in 0..length) {
+    let idx = 0;
+
+    if (style == "up") {
+      idx = i % chordSize;
+    } else {
+      if (style == "down") {
+        idx = chordSize - 1 - (i % chordSize);
+      } else {
+        if (style == "updown") {
+          const cycle = chordSize * 2 - 2;
+          const pos = i % cycle;
+          if (pos < chordSize) {
+            idx = pos;
+          } else {
+            idx = chordSize - 2 - (pos - chordSize);
+          }
+        } else {
+          // random
+          idx = random(chordSize);
+        }
+      }
+    }
+
+    push(pattern, idx);
+  }
+
+  return pattern;
+}