head_music 8.3.0 → 11.0.0

data/lib/head_music/rudiment/scale.rb

@@ -2,13 +2,12 @@
 module HeadMusic::Rudiment; end
 
 # A scale contains ordered pitches starting at a tonal center.
-class HeadMusic::Rudiment::Scale
+class HeadMusic::Rudiment::Scale < HeadMusic::Rudiment::Base
   SCALE_REGEX = /^[A-G][#b]?\s+\w+$/
 
   def self.get(root_pitch, scale_type = nil)
-    root_pitch, scale_type = root_pitch.split(/\s+/) if root_pitch.is_a?(String) && scale_type =~ SCALE_REGEX
     root_pitch = HeadMusic::Rudiment::Pitch.get(root_pitch)
-    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || :major)
+    scale_type = HeadMusic::Rudiment::ScaleType.get(scale_type || HeadMusic::Rudiment::ScaleType::DEFAULT)
     @scales ||= {}
     hash_key = HeadMusic::Utilities::HashKey.for(
       [root_pitch, scale_type].join(" ").gsub(/#|♯/, "sharp").gsub(/(\w)[b♭]/, '\\1flat')
@@ -36,7 +35,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def spellings(direction: :ascending, octaves: 1)
-    pitches(direction: direction, octaves: octaves).map(&:spelling).map(&:to_s)
+    pitches(direction: direction, octaves: octaves).map(&:spelling)
   end
 
   def pitch_names(direction: :ascending, octaves: 1)
@@ -83,7 +82,7 @@ class HeadMusic::Rudiment::Scale
   end
 
   def parent_scale_pitches
-    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches if scale_type.parent
+    HeadMusic::Rudiment::Scale.get(root_pitch, scale_type.parent_name).pitches
   end
 
   def parent_scale_pitch_for(semitones_from_root)

data/lib/head_music/rudiment/scale_degree.rb

@@ -3,7 +3,7 @@ module HeadMusic::Rudiment; end
 
 # A scale degree is a number indicating the ordinality of the spelling in the key.
 # TODO: Rewrite to accept a tonal_center and a scale type.
-class HeadMusic::Rudiment::ScaleDegree
+class HeadMusic::Rudiment::ScaleDegree < HeadMusic::Rudiment::Base
   include Comparable
 
   NAME_FOR_DIATONIC_DEGREE = [nil, "tonic", "supertonic", "mediant", "subdominant", "dominant", "submediant"].freeze

data/lib/head_music/rudiment/scale_type.rb

@@ -2,9 +2,13 @@
 module HeadMusic::Rudiment; end
 
 # A ScaleType represents a particular scale pattern, such as major, lydian, or minor pentatonic.
-class HeadMusic::Rudiment::ScaleType
-  H = 1 # whole step
-  W = 2 # half step
+class HeadMusic::Rudiment::ScaleType < HeadMusic::Rudiment::Base
+  # TODO: load scale types from yaml configuration file
+  # Include a system of aliasing, e.g. :natural_minor, :aeolian
+  # Include ascending and descending intervals for scales that differ
+
+  H = 1 # half step
+  W = 2 # whole step
 
   # Modal
   I = [W, W, H, W, W, W, H].freeze
@@ -33,6 +37,8 @@ class HeadMusic::Rudiment::ScaleType
 
   MINOR_PENTATONIC = [3, 2, 2, 3, 2].freeze
 
+  DEFAULT = :major
+
   def self._modes
     {}.tap do |modes|
       MODE_NAMES.each do |roman_numeral, aliases|

data/lib/head_music/rudiment/solmization.rb

@@ -2,7 +2,7 @@
 module HeadMusic::Rudiment; end
 
 # A solmization is the rendering of scale degrees as syllables.
-class HeadMusic::Rudiment::Solmization
+class HeadMusic::Rudiment::Solmization < HeadMusic::Rudiment::Base
   include HeadMusic::Named
 
   DEFAULT_SOLMIZATION = "solfège"

data/lib/head_music/rudiment/spelling.rb

@@ -4,8 +4,14 @@ module HeadMusic::Rudiment; end
 # Represents the spelling of a pitch, such as C# or Db.
 # Composite of a LetterName and an optional Alteration.
 # Does not include the octave. See Pitch for that.
-class HeadMusic::Rudiment::Spelling
-  MATCHER = /^\s*([A-G])(#{HeadMusic::Rudiment::Alteration.matcher}?)(-?\d+)?\s*$/i
+class HeadMusic::Rudiment::Spelling < HeadMusic::Rudiment::Base
+  LetterName = HeadMusic::Rudiment::LetterName
+  Alteration = HeadMusic::Rudiment::Alteration
+
+  MATCHER = /^\s*(#{LetterName::PATTERN})(#{Alteration::PATTERN})?(-?\d+)?\s*$/i
+
+  # All chromatic spellings using single sharps and flats (ASCII notation)
+  CHROMATIC_SPELLINGS = %w[C C# Db D D# Eb E F F# Gb G G# Ab A A# Bb B].freeze
 
   attr_reader :pitch_class, :letter_name, :alteration
 
@@ -86,8 +92,6 @@ class HeadMusic::Rudiment::Spelling
     !alteration || alteration.natural?
   end
 
-  private_class_method :new
-
   private
 
   def enharmonic_equivalence

data/lib/head_music/rudiment/tempo.rb

@@ -0,0 +1,85 @@
+module HeadMusic::Rudiment; end
+
+# Represents a musical tempo with a beat value and beats per minute
+class HeadMusic::Rudiment::Tempo
+  SECONDS_PER_MINUTE = 60
+  NANOSECONDS_PER_SECOND = 1_000_000_000
+  NANOSECONDS_PER_MINUTE = (NANOSECONDS_PER_SECOND * SECONDS_PER_MINUTE).freeze
+
+  attr_reader :beat_value, :beats_per_minute
+
+  delegate :ticks, to: :beat_value, prefix: true
+  alias_method :ticks_per_beat, :beat_value_ticks
+
+  NAMED_TEMPO_DEFAULTS = {
+    larghissimo: ["quarter", 24],       # 24–40 bpm
+    adagissimo: ["quarter", 32],        # 24–40 bpm
+    grave: ["quarter", 32],             # 24–40 bpm
+    largo: ["quarter", 54],             # 40–66 bpm
+    larghetto: ["quarter", 54],         # 44–66 bpm
+    adagio: ["quarter", 60],            # 44–66 bpm
+    adagietto: ["quarter", 68],         # 46–80 bpm
+    lento: ["quarter", 72],             # 52–108 bpm
+    marcia_moderato: ["quarter", 72],   # 66–80 bpm
+    andante: ["quarter", 78],           # 56–108 bpm
+    andante_moderato: ["quarter", 88],  # 80–108 bpm
+    andantino: ["quarter", 92],         # 80–108 bpm
+    moderato: ["quarter", 108],         # 108–120 bpm
+    allegretto: ["quarter", 112],       # 112–120 bpm
+    allegro_moderato: ["quarter", 116], # 116–120 bpm
+    allegro: ["quarter", 120],          # 120–156 bpm
+    molto_allegro: ["quarter", 132],    # 124–156 bpm
+    allegro_vivace: ["quarter", 132],   # 124–156 bpm
+    vivace: ["quarter", 156],           # 156–176 bpm
+    vivacissimo: ["quarter", 172],      # 172–176 bpm
+    allegrissimo: ["quarter", 172],     # 172–176 bpm
+    presto: ["quarter", 180],           # 168–200 bpm
+    prestissimo: ["quarter", 200]      # 200 bpm and over
+  }.freeze
+
+  def self.get(identifier)
+    @tempos ||= {}
+    key = HeadMusic::Utilities::HashKey.for(identifier)
+    if NAMED_TEMPO_DEFAULTS.key?(identifier.to_s.to_sym)
+      beat_value, beats_per_minute = NAMED_TEMPO_DEFAULTS[identifier.to_s.to_sym]
+      @tempos[key] ||= new(beat_value, beats_per_minute)
+    elsif identifier.to_s.match?(/=|at/)
+      parts = identifier.to_s.split(/\s*(=|at)\s*/)
+      unit = parts[0]
+      bpm = parts[2] || parts[1]  # Handle both "q = 120" and "q at 120bpm"
+      bpm_value = bpm.to_s.gsub(/[^0-9]/, "").to_i
+      @tempos[key] ||= new(standardized_unit(unit), bpm_value)
+    else
+      @tempos[key] ||= new("quarter", 120)
+    end
+    @tempos[key]
+  end
+
+  def initialize(beat_value, beats_per_minute)
+    @beat_value = HeadMusic::Rudiment::RhythmicValue.get(beat_value)
+    @beats_per_minute = beats_per_minute.to_f
+  end
+
+  def beat_duration_in_seconds
+    @beat_duration_in_seconds ||=
+      SECONDS_PER_MINUTE / beats_per_minute
+  end
+
+  def beat_duration_in_nanoseconds
+    @beat_duration_in_nanoseconds ||=
+      NANOSECONDS_PER_MINUTE / beats_per_minute
+  end
+
+  def tick_duration_in_nanoseconds
+    @tick_duration_in_nanoseconds ||=
+      beat_duration_in_nanoseconds / ticks_per_beat
+  end
+
+  def self.standardized_unit(unit)
+    return "quarter" if unit.nil?
+
+    # Use RhythmicValue parser to handle all formats (shorthand, fractions, British names, dots, etc.)
+    rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(unit)
+    rhythmic_value&.unit ? rhythmic_value.to_s : "quarter"
+  end
+end

data/lib/head_music/rudiment/tonal_context.rb

@@ -0,0 +1,35 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Abstract base class representing a tonal context (system of pitches with a tonal center)
+class HeadMusic::Rudiment::TonalContext < HeadMusic::Rudiment::Base
+  attr_reader :tonic_spelling
+
+  def initialize(tonic_spelling)
+    @tonic_spelling = HeadMusic::Rudiment::Spelling.get(tonic_spelling)
+  end
+
+  def tonic_pitch(octave = 4)
+    HeadMusic::Rudiment::Pitch.get("#{tonic_spelling}#{octave}")
+  end
+
+  def scale
+    raise NotImplementedError, "Subclasses must implement #scale"
+  end
+
+  def pitches(octave = nil)
+    scale.pitches(direction: :ascending, octaves: 1)
+  end
+
+  def pitch_classes
+    scale.pitch_classes
+  end
+
+  def spellings
+    scale.spellings
+  end
+
+  def key_signature
+    raise NotImplementedError, "Subclasses must implement #key_signature"
+  end
+end

data/lib/head_music/rudiment/tuning/just_intonation.rb

@@ -43,43 +43,4 @@ class HeadMusic::Rudiment::Tuning::JustIntonation < HeadMusic::Rudiment::Tuning
     # Calculate the frequency
     tonal_center_frequency * ratio
   end
-
-  private
-
-  def calculate_tonal_center_frequency
-    # Use equal temperament to get the tonal center frequency from the reference pitch
-    interval_to_tonal_center = (tonal_center - reference_pitch.pitch).semitones
-    reference_pitch_frequency * (2**(interval_to_tonal_center / 12.0))
-  end
-
-  def ratio_for_interval(semitones)
-    # Handle octaves
-    octaves = semitones / 12
-    interval_within_octave = semitones % 12
-
-    # Make sure we handle negative intervals
-    if interval_within_octave < 0
-      interval_within_octave += 12
-      octaves -= 1
-    end
-
-    # Get the base ratio
-    base_ratio = case interval_within_octave
-    when 0 then INTERVAL_RATIOS[:unison]
-    when 1 then INTERVAL_RATIOS[:minor_second]
-    when 2 then INTERVAL_RATIOS[:major_second]
-    when 3 then INTERVAL_RATIOS[:minor_third]
-    when 4 then INTERVAL_RATIOS[:major_third]
-    when 5 then INTERVAL_RATIOS[:perfect_fourth]
-    when 6 then INTERVAL_RATIOS[:tritone]
-    when 7 then INTERVAL_RATIOS[:perfect_fifth]
-    when 8 then INTERVAL_RATIOS[:minor_sixth]
-    when 9 then INTERVAL_RATIOS[:major_sixth]
-    when 10 then INTERVAL_RATIOS[:minor_seventh]
-    when 11 then INTERVAL_RATIOS[:major_seventh]
-    end
-
-    # Apply octave adjustments
-    base_ratio * (2**octaves)
-  end
 end

data/lib/head_music/rudiment/tuning/meantone.rb

@@ -45,43 +45,4 @@ class HeadMusic::Rudiment::Tuning::Meantone < HeadMusic::Rudiment::Tuning
     # Calculate the frequency
     tonal_center_frequency * ratio
   end
-
-  private
-
-  def calculate_tonal_center_frequency
-    # Use equal temperament to get the tonal center frequency from the reference pitch
-    interval_to_tonal_center = (tonal_center - reference_pitch.pitch).semitones
-    reference_pitch_frequency * (2**(interval_to_tonal_center / 12.0))
-  end
-
-  def ratio_for_interval(semitones)
-    # Handle octaves
-    octaves = semitones / 12
-    interval_within_octave = semitones % 12
-
-    # Make sure we handle negative intervals
-    if interval_within_octave < 0
-      interval_within_octave += 12
-      octaves -= 1
-    end
-
-    # Get the base ratio
-    base_ratio = case interval_within_octave
-    when 0 then INTERVAL_RATIOS[:unison]
-    when 1 then INTERVAL_RATIOS[:minor_second]
-    when 2 then INTERVAL_RATIOS[:major_second]
-    when 3 then INTERVAL_RATIOS[:minor_third]
-    when 4 then INTERVAL_RATIOS[:major_third]
-    when 5 then INTERVAL_RATIOS[:perfect_fourth]
-    when 6 then INTERVAL_RATIOS[:tritone]
-    when 7 then INTERVAL_RATIOS[:perfect_fifth]
-    when 8 then INTERVAL_RATIOS[:minor_sixth]
-    when 9 then INTERVAL_RATIOS[:major_sixth]
-    when 10 then INTERVAL_RATIOS[:minor_seventh]
-    when 11 then INTERVAL_RATIOS[:major_seventh]
-    end
-
-    # Apply octave adjustments
-    base_ratio * (2**octaves)
-  end
 end

data/lib/head_music/rudiment/tuning/pythagorean.rb

@@ -49,43 +49,4 @@ class HeadMusic::Rudiment::Tuning::Pythagorean < HeadMusic::Rudiment::Tuning
     # Calculate the frequency
     tonal_center_frequency * ratio
   end
-
-  private
-
-  def calculate_tonal_center_frequency
-    # Use equal temperament to get the tonal center frequency from the reference pitch
-    interval_to_tonal_center = (tonal_center - reference_pitch.pitch).semitones
-    reference_pitch_frequency * (2**(interval_to_tonal_center / 12.0))
-  end
-
-  def ratio_for_interval(semitones)
-    # Handle octaves
-    octaves = semitones / 12
-    interval_within_octave = semitones % 12
-
-    # Make sure we handle negative intervals
-    if interval_within_octave < 0
-      interval_within_octave += 12
-      octaves -= 1
-    end
-
-    # Get the base ratio
-    base_ratio = case interval_within_octave
-    when 0 then INTERVAL_RATIOS[:unison]
-    when 1 then INTERVAL_RATIOS[:minor_second]
-    when 2 then INTERVAL_RATIOS[:major_second]
-    when 3 then INTERVAL_RATIOS[:minor_third]
-    when 4 then INTERVAL_RATIOS[:major_third]
-    when 5 then INTERVAL_RATIOS[:perfect_fourth]
-    when 6 then INTERVAL_RATIOS[:tritone]
-    when 7 then INTERVAL_RATIOS[:perfect_fifth]
-    when 8 then INTERVAL_RATIOS[:minor_sixth]
-    when 9 then INTERVAL_RATIOS[:major_sixth]
-    when 10 then INTERVAL_RATIOS[:minor_seventh]
-    when 11 then INTERVAL_RATIOS[:major_seventh]
-    end
-
-    # Apply octave adjustments
-    base_ratio * (2**octaves)
-  end
 end

data/lib/head_music/rudiment/tuning.rb

@@ -3,7 +3,7 @@ module HeadMusic::Rudiment; end
 
 # A tuning has a reference pitch and frequency and provides frequencies for all pitches
 # The base class assumes equal temperament tuning. By default, A4 = 440.0 Hz
-class HeadMusic::Rudiment::Tuning
+class HeadMusic::Rudiment::Tuning < HeadMusic::Rudiment::Base
   attr_accessor :reference_pitch
 
   delegate :pitch, :frequency, to: :reference_pitch, prefix: true
@@ -32,4 +32,24 @@ class HeadMusic::Rudiment::Tuning
     pitch = HeadMusic::Rudiment::Pitch.get(pitch)
     reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
   end
+
+  private
+
+  def calculate_tonal_center_frequency
+    # Use equal temperament to get the tonal center frequency from the reference pitch
+    interval_to_tonal_center = (tonal_center - reference_pitch.pitch).semitones
+    reference_pitch_frequency * (2**(interval_to_tonal_center / 12.0))
+  end
+
+  def ratio_for_interval(semitones)
+    # Handle octaves
+    octaves = semitones / 12
+    interval_within_octave = semitones % 12
+
+    # Get the base ratio from the subclass's INTERVAL_RATIOS constant
+    base_ratio = self.class::INTERVAL_RATIOS[self.class::INTERVAL_RATIOS.keys[interval_within_octave]]
+
+    # Apply octave adjustments
+    base_ratio * (2**octaves)
+  end
 end

data/lib/head_music/rudiment/unpitched_note.rb

@@ -0,0 +1,62 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# An UnpitchedNote represents a percussion note with rhythm but no specific pitch.
+# It inherits from RhythmicElement and can optionally have an instrument name.
+class HeadMusic::Rudiment::UnpitchedNote < HeadMusic::Rudiment::RhythmicElement
+  include HeadMusic::Named
+
+  attr_reader :instrument_name
+
+  # Make new public for this concrete class
+  public_class_method :new
+
+  def self.get(rhythmic_value, instrument: nil)
+    return rhythmic_value if rhythmic_value.is_a?(HeadMusic::Rudiment::UnpitchedNote)
+
+    rhythmic_value = HeadMusic::Rudiment::RhythmicValue.get(rhythmic_value)
+    return nil unless rhythmic_value
+
+    fetch_or_create(rhythmic_value, instrument)
+  end
+
+  def self.fetch_or_create(rhythmic_value, instrument_name)
+    @unpitched_notes ||= {}
+    hash_key = [rhythmic_value.to_s, instrument_name].compact.join("_")
+    @unpitched_notes[hash_key] ||= new(rhythmic_value, instrument_name)
+  end
+
+  def initialize(rhythmic_value, instrument_name = nil)
+    super(rhythmic_value)
+    @instrument_name = instrument_name
+  end
+
+  def name
+    if instrument_name
+      "#{rhythmic_value} #{instrument_name}"
+    else
+      "#{rhythmic_value} unpitched note"
+    end
+  end
+
+  # Override with_rhythmic_value to preserve instrument
+  def with_rhythmic_value(new_rhythmic_value)
+    self.class.get(new_rhythmic_value, instrument: instrument_name)
+  end
+
+  # Create a new unpitched note with a different instrument
+  def with_instrument(new_instrument_name)
+    self.class.get(rhythmic_value, instrument: new_instrument_name)
+  end
+
+  def ==(other)
+    return false unless other.is_a?(self.class)
+    rhythmic_value == other.rhythmic_value && instrument_name == other.instrument_name
+  end
+
+  def sounded?
+    true
+  end
+
+  private_class_method :fetch_or_create
+end

data/lib/head_music/style/guidelines/consonant_climax.rb

@@ -27,11 +27,11 @@ class HeadMusic::Style::Guidelines::ConsonantClimax < HeadMusic::Style::Annotati
   end
 
   def highest_pitch_consonant_with_tonic?
-    diatonic_interval_to_highest_pitch.consonance?(:melodic)
+    !diatonic_interval_to_highest_pitch.dissonant?(:melodic)
   end
 
   def lowest_pitch_consonant_with_tonic?
-    diatonic_interval_to_lowest_pitch.consonance?(:melodic)
+    !diatonic_interval_to_lowest_pitch.dissonant?(:melodic)
   end
 
   def diatonic_interval_to_highest_pitch

data/lib/head_music/style/medieval_tradition.rb

@@ -0,0 +1,26 @@
+# Medieval tradition for interval consonance classification
+class HeadMusic::Style::MedievalTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals
+    if interval.augmented? || interval.diminished?
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0, 12  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7      # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 5      # Perfect Fourth - consonant in medieval music
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4   # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9   # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    else
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/modern_tradition.rb

@@ -0,0 +1,31 @@
+# Modern/standard practice tradition for interval consonance classification
+class HeadMusic::Style::ModernTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals (except diminished fifth/augmented fourth)
+    if (interval.augmented? || interval.diminished?) && interval_mod != 6
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7  # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4  # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9  # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 5  # Perfect Fourth
+      # Perfect fourth is contextual: consonant in upper voices, dissonant against bass
+      HeadMusic::Rudiment::Consonance::CONTEXTUAL
+    when 2, 10  # Major Second, Minor Seventh
+      HeadMusic::Rudiment::Consonance::MILD_DISSONANCE
+    when 1, 11  # Minor Second, Major Seventh
+      HeadMusic::Rudiment::Consonance::HARSH_DISSONANCE
+    when 6  # Tritone (Aug 4th/Dim 5th)
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/renaissance_tradition.rb

@@ -0,0 +1,26 @@
+# Renaissance counterpoint tradition for interval consonance classification
+class HeadMusic::Style::RenaissanceTradition < HeadMusic::Style::Tradition
+  def consonance_classification(interval)
+    interval_mod = interval.simple_semitones
+
+    # Check for augmented or diminished intervals
+    if interval.augmented? || interval.diminished?
+      return HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+
+    case interval_mod
+    when 0, 12  # Unison, Octave
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 7      # Perfect Fifth
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    when 3, 4   # Minor Third, Major Third
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 8, 9   # Minor Sixth, Major Sixth
+      HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+    when 5      # Perfect Fourth - dissonant in Renaissance counterpoint
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    else
+      HeadMusic::Rudiment::Consonance::DISSONANCE
+    end
+  end
+end

data/lib/head_music/style/tradition.rb

@@ -0,0 +1,21 @@
+# A style tradition represents a historical or theoretical approach to music
+module HeadMusic::Style
+  class Tradition
+    def self.get(name)
+      case name&.to_sym
+      when :modern, :standard_practice then ModernTradition.new
+      when :renaissance_counterpoint, :two_part_harmony then RenaissanceTradition.new
+      when :medieval then MedievalTradition.new
+      else ModernTradition.new
+      end
+    end
+
+    def consonance_classification(interval)
+      raise NotImplementedError, "#{self.class} must implement consonance_classification"
+    end
+
+    def name
+      HeadMusic::Utilities::Case.to_snake_case(self.class.name.split("::").last.sub(/Tradition$/, "")).to_sym
+    end
+  end
+end

data/lib/head_music/time/clock_position.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module HeadMusic
+  module Time
+    # A value object representing elapsed nanoseconds of clock time
+    #
+    # ClockPosition provides a high-precision representation of time elapsed
+    # from a reference point, stored as nanoseconds. This allows for precise
+    # temporal calculations in musical contexts where millisecond-level accuracy
+    # is required for MIDI timing, audio synchronization, and SMPTE timecode.
+    #
+    # @example Creating a position at one second
+    #   position = HeadMusic::Time::ClockPosition.new(1_000_000_000)
+    #   position.to_seconds # => 1.0
+    #
+    # @example Adding two positions together
+    #   pos1 = HeadMusic::Time::ClockPosition.new(500_000_000)
+    #   pos2 = HeadMusic::Time::ClockPosition.new(300_000_000)
+    #   result = pos1 + pos2
+    #   result.to_milliseconds # => 800.0
+    #
+    # @example Comparing positions
+    #   early = HeadMusic::Time::ClockPosition.new(1_000_000_000)
+    #   late = HeadMusic::Time::ClockPosition.new(2_000_000_000)
+    #   early < late # => true
+    class ClockPosition
+      include Comparable
+
+      # @return [Integer] the number of nanoseconds since the reference point
+      attr_reader :nanoseconds
+
+      # Create a new clock position
+      #
+      # @param nanoseconds [Integer] the number of nanoseconds elapsed
+      def initialize(nanoseconds)
+        @nanoseconds = nanoseconds
+      end
+
+      # Convert to integer representation (nanoseconds)
+      #
+      # @return [Integer] nanoseconds
+      def to_i
+        nanoseconds
+      end
+
+      # Convert nanoseconds to microseconds
+      #
+      # @return [Float] elapsed microseconds
+      def to_microseconds
+        nanoseconds / 1_000.0
+      end
+
+      # Convert nanoseconds to milliseconds
+      #
+      # @return [Float] elapsed milliseconds
+      def to_milliseconds
+        nanoseconds / 1_000_000.0
+      end
+
+      # Convert nanoseconds to seconds
+      #
+      # @return [Float] elapsed seconds
+      def to_seconds
+        nanoseconds / 1_000_000_000.0
+      end
+
+      # Add another clock position to this one
+      #
+      # @param other [ClockPosition, #to_i] another position or value with nanoseconds
+      # @return [ClockPosition] a new position with the combined duration
+      def +(other)
+        self.class.new(nanoseconds + other.to_i)
+      end
+
+      # Compare this position to another
+      #
+      # @param other [ClockPosition, #to_i] another position to compare
+      # @return [Integer] -1 if less than, 0 if equal, 1 if greater than
+      def <=>(other)
+        nanoseconds <=> other.to_i
+      end
+    end
+  end
+end