Comping

generator/comping_rhythm.py

@@ -1,7 +1,6 @@
-"""Bounded, source-only measure rhythms; acoustic layers are selected jointly."""
+"""Complete, source-only comping figures. Time is in rational quarter notes."""
 import dataclasses
 import fractions
-import itertools
 
 import generator.accompaniment
 import generator.model
@@ -14,6 +13,7 @@ class Attack:
   lane: str
   start: fractions.Fraction
   end: fractions.Fraction
+  harmonic_time: fractions.Fraction | None = None
 
 @dataclasses.dataclass(frozen=True)
 class Rhythm:
@@ -21,12 +21,13 @@ class Rhythm:
   families: tuple
   contributions: tuple
   exceptions: tuple = ()
+  pattern_id: str = ''
   @property
   def cost(self):
     return sum(value for _, value in self.contributions)
   @property
   def signature(self):
-    return tuple((e.lane, str(e.start), str(e.end - e.start)) for e in self.events)
+    return tuple((e.lane, str(e.start), str(e.end - e.start), str(e.harmonic_time)) for e in self.events)
 
 def melody_contexts(document):
   melody = generator.solo.analysis.attacks(document)
@@ -49,151 +50,136 @@ def spans(measure, prior):
       result.append((a, b, chord))
   return tuple(result)
 
-def lane_score(events, lane, melody, harmony, length):
-  """Named source-context preferences, independent of the deterministic seed."""
-  attacks = [a for a, b in melody if a >= 0]
-  occupied = sum((max(0, min(length, b) - max(0, a)) for a, b in melody), fractions.Fraction())
-  space = max(0, length - occupied)
-  busy = len(attacks) >= length
-  if lane == 'bass':
-    target = min(2, sum(c is not None and b - a >= 1 for a, b, c in harmony))
-  elif lane == 'upper':
-    target = 2.5 if space >= length / 2 else 1.5 if busy else 2
-  else:
-    target = .5 if busy else 1.5 if space >= length / 2 else 1
-  # A half-attack tolerance makes neighboring densities genuine alternatives.
-  # The objective does not always fill up to a layer's permitted maximum.
-  activity = .35 * max(0, abs(len(events) - target) - .5)
-  support, articulation = 0., 0.
-  for e in events:
-    # Supporting an entrance is different from doubling every moving note.
-    entrance = any(a == e.start and (i == 0 and a >= 0 or i > 0 and a - melody[i - 1][1] >= fractions.Fraction(1, 2)) for i, (a, _) in enumerate(melody))
-    moving = any(a <= e.start < b and b - a <= 1 for a, b in melody)
-    gap = not any(a <= e.start < b for a, b in melody)
-    if lane != 'bass':
-      support += -.2 if entrance else .25 if moving and e.start in attacks else -.15 if gap else 0
-      articulation += .12 if busy and e.end - e.start > 1 else .08 if not busy and e.end - e.start < 1 else 0
-    elif e.start and e.start.denominator != 1:
-      support += .15
-  divisor = max(1, len(events))
-  return (('activity', activity), ('melody_support', support / divisor), ('duration_contrast', articulation / divisor))
+def flatten(inputs):
+  """Harmony/timing adapter only; never concatenate separately chosen rhythms."""
+  first = inputs[0][0]
+  result = {**first, 'harmonies': []}
+  cursor = fractions.Fraction()
+  for m, prior, _ in inputs:
+    chord = generator.accompaniment.active_chord(m, fractions.Fraction(), prior)
+    initial = chord or {'kind': 'none'}
+    result['harmonies'].append({**initial, 'onset': generator.model.rational(cursor)})
+    result['harmonies'].extend({**h, 'onset': generator.model.rational(cursor + generator.model.fraction(h['onset']))} for h in m['harmonies'] if generator.model.fraction(h['onset']))
+    cursor += generator.model.fraction(m['duration'])
+  result['duration'] = generator.model.rational(cursor)
+  return result
+
+def validate_events(events, part):
+  ordered = sorted(events, key=lambda e: e.start)
+  for e in ordered:
+    duration = e.end - e.start
+    if duration <= 0:
+      raise ValueError('comping event must have positive sounding duration')
+    if part == 'acoustic':
+      if e.lane == 'combined':
+        if duration <= 1:
+          raise ValueError('combined acoustic sustain must exceed one beat')
+      elif e.lane not in ('bass', 'upper') or duration not in (fractions.Fraction(1, 2), 1):
+        raise ValueError('ordinary acoustic attacks require separate quarter/eighth notes')
+    elif e.lane != 'electric':
+      raise ValueError('electric comping requires chord events')
+  if any(a.end > b.start for a, b in zip(ordered, ordered[1:])):
+    raise ValueError('separate comping events cannot overlap; use one combined sustain')
+
+def fit(pattern, measure, prior, part, *, anticipate=False, limit=None):
+  """Bind a complete figure to written harmony, with bounded early arrivals."""
+  length = generator.model.fraction(measure['duration'])
+  limit = length if limit is None else min(length, limit)
+  harmony = spans(measure, prior)
+  events, exceptions = [], []
+  for row in pattern['events']:
+    start = fractions.Fraction(row['onset'])
+    end = min(start + fractions.Fraction(row['duration']), limit)
+    if start >= limit:
+      continue
+    active = next(((a, b, c) for a, b, c in harmony if a <= start < b), None)
+    if active is None or active[2] is None:
+      exceptions.append(('space', 'no written harmony at ' + str(start)))
+      continue
+    _, boundary, chord = active
+    target = None
+    if anticipate and row.get('anticipate') and row['layer'] in ('upper', 'electric'):
+      future = next(((a, b, c) for a, b, c in harmony if a == start + fractions.Fraction(1, 2) and c), None)
+      if future and future[0] < end and not generator.accompaniment.same_chord(chord, future[2]):
+        target, boundary = future[0], future[1]
+    end = min(end, boundary)
+    events.append(Attack(row['layer'], start, end, target))
+  try:
+    validate_events(events, part)
+  except ValueError:
+    return None
+  return tuple(events), tuple(exceptions)
+
+def evaluate(events, part, melody, harmony, lengths):
+  activity, support, coverage, articulation = 0., 0., 0., 0.
+  cursor = fractions.Fraction()
+  for length in lengths:
+    local = [e for e in events if cursor <= e.start < cursor + length]
+    attacks = [a for a, b in melody if cursor <= a < cursor + length]
+    busy = len(attacks) >= length
+    sounding = any(e.start < cursor + length and e.end > cursor for e in events)
+    target = (1 if busy else 1.5) if part == 'electric' else (2 if busy else 2.5)
+    # Sustained occupancy and planned space are not missing attacks.
+    activity += .22 * max(0, abs(len(local) - target) - .75) if not (sounding and not local) else 0
+    for e in local:
+      gap = not any(a <= e.start < b for a, b in melody)
+      entrance = any(a == e.start and (i == 0 or a - melody[i - 1][1] >= fractions.Fraction(1, 2)) for i, (a, _) in enumerate(melody))
+      support += -.2 if entrance else -.12 if gap else .18 if busy and e.start in attacks else 0
+      articulation += .08 if busy and e.end - e.start > 2 else 0
+    cursor += length
+  for a, b, chord in harmony:
+    if chord and b - a >= 1 and not any(e.start < b and e.end > a for e in events):
+      coverage += .18  # A preference, never a chord-attack quota.
+  divisor = max(1, len(lengths))
+  return tuple((k, v / divisor) for k, v in (('activity', activity), ('melody_support', support), ('harmonic_support', coverage), ('articulation', articulation)))
+
+def candidates(measure, prior, part, melody, seed, *, lengths=None, limit=None):
+  lengths = lengths or (generator.model.fraction(measure['duration']),)
+  policy = generator.vocabulary.accompaniment(part)
+  result = []
+  for pattern in policy['patterns']:
+    if tuple(map(fractions.Fraction, pattern['lengths'])) != tuple(lengths):
+      continue
+    for anticipate in (False, True):
+      fitted = fit(pattern, measure, prior, part, anticipate=anticipate, limit=limit)
+      if fitted is None:
+        continue
+      events, exceptions = fitted
+      if anticipate and not any(e.harmonic_time is not None for e in events):
+        continue
+      contributions = evaluate(events, part, melody, spans(measure, prior), lengths)
+      result.append(Rhythm(events, (('pattern', pattern['family']),), contributions, exceptions, pattern['id'] + ('.anticipated' if anticipate else '')))
+  if not result:
+    raise ValueError(f'measure {measure["number"]}: no {part} pattern for lengths {lengths} and written harmonic/release constraints')
+  return representatives(result, policy['pattern_candidates'], seed)
 
 def representatives(candidates, limit, seed):
-  """Keep counts, placements and duration families before the final cutoff."""
   unique = {}
-  for candidate in candidates:
-    key = candidate.signature
-    rank = (candidate.cost, generator.solo.policy.stable_rank(seed, key))
-    if key not in unique or rank < unique[key][0]:
-      unique[key] = rank, candidate
-  ordered = [v for _, v in sorted(unique.values(), key=lambda item: item[0])]
-  groups = {}
-  shapes = set()
+  for c in candidates:
+    rank = (c.cost, generator.solo.policy.stable_rank(seed, (c.pattern_id, c.signature)))
+    if c.signature not in unique or rank < unique[c.signature][0]:
+      unique[c.signature] = rank, c
+  ordered = [c for _, c in sorted(unique.values(), key=lambda item: item[0])]
+  retained, families = [], set()
   for c in ordered:
-    counts = tuple((lane, sum(e.lane == lane for e in c.events)) for lane, _ in c.families)
-    shape = (counts, c.families, any(e.start.denominator != 1 for e in c.events))
-    # Round-robin attack counts first. Otherwise many cosmetic variants of
-    # the cheapest density can exclude every one- or three-attack idea.
-    if shape not in shapes:
-      groups.setdefault(counts, []).append(c)
-      shapes.add(shape)
-  result = []
-  while groups and len(result) < limit:
-    for key in list(groups):
-      result.append(groups[key].pop(0))
-      if not groups[key]:
-        del groups[key]
-      if len(result) == limit:
-        break
-  return tuple(result)
-
-def lane_candidates(measure, prior, lane, melody, policy, seed):
-  length = generator.model.fraction(measure['duration'])
-  harmony = spans(measure, prior)
-  active = [(a, b, c) for a, b, c in harmony if c]
-  if not active:
-    return Rhythm((), ((lane, 'space'),), (('activity', 0.),)),
-  low, high = policy['layers'][lane]['attacks']
-  # Genuinely different harmony gets a gesture, not its own density budget.
-  required = [(a, b) for a, b, c in active if b - a >= (2 if lane == 'bass' else 1)]
-  if lane == 'bass' and active[0][0] == 0 and not any(a == 0 for a, _ in required):
-    required.insert(0, active[0][:2])
-  if lane == 'electric' and len(active) == 1 and generator.accompaniment.same_chord(active[0][2], prior):
-    required = []
-  # With very fast harmonic rhythm, establish the edges and longest spans.
-  # Short intervening chords may be silent; no incompatible sustain is kept.
-  if len(required) > high + 1:
-    edges = [required[0], required[-1]]
-    required = sorted(edges + sorted(required[1:-1], key=lambda ab: (-(ab[1] - ab[0]), ab[0]))[:high - 1])
-  extra = int(len(required) > high)
-  grid = fractions.Fraction(policy['grid'])
-  positions = {i * grid for i in range(int(length / grid) + 1) if i * grid < length}
-  positions.update(a for a, _, _ in active)
-  positions = sorted(t for t in positions if any(a <= t < b for a, b, _ in active))
-  result = []
-  for count in range(low, high + extra + 1):
-    for onsets in itertools.combinations(positions, count):
-      if lane == 'bass' and active[0][0] == 0 and (not onsets or onsets[0] != 0):
-        continue
-      if any(not any(a <= t < b for t in onsets) for a, b in required):
-        continue
-      if any(b - a < fractions.Fraction(policy['attack_spacing']) for a, b in zip(onsets, onsets[1:])):
-        continue
-      for family in policy['layers'][lane]['families']:
-        durations = policy['families'][family]
-        events = []
-        for i, a in enumerate(onsets):
-          end = next(b for start, b, c in active if start <= a < b)
-          following = onsets[i + 1] if i + 1 < len(onsets) else length
-          duration = fractions.Fraction(durations[i % len(durations)])
-          events.append(Attack(lane, a, min(a + duration, following, end)))
-        if policy.get('allowed_durations') and any(e.end - e.start not in tuple(map(fractions.Fraction, policy['allowed_durations'])) for e in events):
-          continue
-        exceptions = ((lane, 'extra attack for harmonic changes'),) if count > high else ()
-        contributions = (*lane_score(events, lane, melody, harmony, length), ('extra_attacks', .5 * bool(exceptions)))
-        result.append(Rhythm(tuple(events), ((lane, family if count else 'space'),), contributions, exceptions))
-  if not result:
-    # A short partial bar can have fewer gestures, not invented subdivisions.
-    if length < 1 and not policy.get('allowed_durations'):
-      a, b, _ = active[0]
-      return Rhythm((Attack(lane, a, b),), ((lane, 'partial'),), (('activity', 0.),)),
-    raise ValueError(f'measure {measure["number"]}: no {lane} rhythm within the bounded attack/spacing policy')
-  return representatives(result, policy['lane_candidates'], seed + '/' + lane)
-
-def crowding(events):
-  times = sorted({e.start for e in events})
-  cost = .22 * sum(y - x < 1 for x, y in zip(times, times[1:]))
-  # Three successive half-beat changes are a busy figure even though each
-  # layer is sparse. Coincident attacks count as one hand action.
-  return cost + .5 * sum(z - x <= 1 for x, y, z in zip(times, times[1:], times[2:]))
-
-def candidates(measure, prior, part, melody, seed):
-  policy = generator.vocabulary.accompaniment(part)
-  if part == 'electric':
-    return lane_candidates(measure, prior, 'electric', melody, policy, seed)
-  bass = lane_candidates(measure, prior, 'bass', melody, policy, seed)
-  upper = lane_candidates(measure, prior, 'upper', melody, policy, seed)
-  result = []
-  for a, b in itertools.product(bass, upper):
-    costs = tuple((lane + '_' + k, v) for lane, c in (('bass', a), ('upper', b)) for k, v in c.contributions)
-    result.append(Rhythm(tuple(sorted((*a.events, *b.events))), (*a.families, *b.families), (*costs, ('combined_crowding', crowding((*a.events, *b.events)))), (*a.exceptions, *b.exceptions)))
-  return representatives(result, policy['measure_candidates'], seed)
+    if c.families not in families:
+      retained.append(c)
+      families.add(c.families)
+  retained.extend(c for c in ordered if c not in retained)
+  return tuple(retained[:limit])
 
 def transition(previous, current):
   if previous is None:
     return 0.
-  # Recurrence is allowed; penalize repeating an entire bar more than sharing
-  # a duration family. This stays separate from the source-context objective.
-  same_counts = all(sum(e.lane == lane for e in previous.events) == sum(e.lane == lane for e in current.events) for lane, _ in current.families)
-  return .45 * (previous.signature == current.signature) + .12 * (previous.families == current.families) + .08 * same_counts
+  return .18 * (previous.signature == current.signature) + .04 * (previous.families == current.families)
 
 def select(layers, seed, left=None, right=None):
-  """One state per concrete bar rhythm; compare complete equal-span paths."""
+  """Compare complete two-bar paths, not independently chosen bar fragments."""
   states = [(0., (), (), left)]
   for i, layer in enumerate(layers):
     following = []
     for c in layer:
-      options = [(cost + c.cost + transition(previous, c), (*ties, generator.solo.policy.stable_rank(seed, (i, c.signature))), (*path, c), c) for cost, ties, path, previous in states]
+      options = [(cost + c.cost + transition(previous, c), (*ties, generator.solo.policy.stable_rank(seed, (i, c.pattern_id, c.signature))), (*path, c), c) for cost, ties, path, previous in states]
       following.append(min(options, key=lambda item: item[:2]))
     states = following
   return min(states, key=lambda item: (item[0] + (transition(item[3], right) if right else 0), item[1]))[2]