head_music 8.2.1 → 9.0.1

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
+  }
+
+  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

@@ -0,0 +1,85 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Just Intonation tuning system based on whole number frequency ratios
+class HeadMusic::Rudiment::Tuning::JustIntonation < HeadMusic::Rudiment::Tuning
+  # Frequency ratios for intervals in just intonation (relative to tonic)
+  # Based on the major scale with pure intervals
+  INTERVAL_RATIOS = {
+    unison: Rational(1, 1),
+    minor_second: Rational(16, 15),
+    major_second: Rational(9, 8),
+    minor_third: Rational(6, 5),
+    major_third: Rational(5, 4),
+    perfect_fourth: Rational(4, 3),
+    tritone: Rational(45, 32),
+    perfect_fifth: Rational(3, 2),
+    minor_sixth: Rational(8, 5),
+    major_sixth: Rational(5, 3),
+    minor_seventh: Rational(16, 9),
+    major_seventh: Rational(15, 8),
+    octave: Rational(2, 1)
+  }.freeze
+
+  attr_reader :tonal_center
+
+  def initialize(reference_pitch: :a440, tonal_center: nil)
+    super
+    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
+  end
+
+  def frequency_for(pitch)
+    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
+
+    # Calculate the frequency of the tonal center using equal temperament from reference pitch
+    tonal_center_frequency = calculate_tonal_center_frequency
+
+    # Calculate the interval from the tonal center to the requested pitch
+    interval_from_tonal_center = (pitch - tonal_center).semitones
+
+    # Get the just intonation ratio for this interval
+    ratio = ratio_for_interval(interval_from_tonal_center)
+
+    # 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

@@ -0,0 +1,87 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Quarter-comma meantone temperament
+# Optimizes major thirds to be pure (5:4) at the expense of perfect fifths
+class HeadMusic::Rudiment::Tuning::Meantone < HeadMusic::Rudiment::Tuning
+  # Frequency ratios for intervals in quarter-comma meantone temperament
+  # The defining characteristic is that major thirds are pure (5:4)
+  # and the syntonic comma is distributed equally among the four fifths
+  INTERVAL_RATIOS = {
+    unison: Rational(1, 1),
+    minor_second: 5.0**(1.0 / 4) / 2.0**(1.0 / 2),     # ~1.0697
+    major_second: 5.0**(1.0 / 4),                       # ~1.1892 (fourth root of 5)
+    minor_third: 5.0**(1.0 / 2) / 2.0**(1.0 / 2),      # ~1.5811
+    major_third: Rational(5, 4),                        # Pure major third (1.25)
+    perfect_fourth: 2.0**(1.0 / 2) / 5.0**(1.0 / 4),   # ~1.3375
+    tritone: 5.0**(3.0 / 4) / 2.0**(1.0 / 2),          # ~1.6719
+    perfect_fifth: Rational(3, 2),                      # ~1.4953 (slightly flat)
+    minor_sixth: 2.0**(3.0 / 2) / 5.0**(1.0 / 4),      # ~1.6818
+    major_sixth: 5.0**(3.0 / 4),                        # ~1.8877
+    minor_seventh: 2.0**(3.0 / 2) / 5.0**(1.0 / 2),    # ~1.8877
+    major_seventh: Rational(25, 16),                    # ~1.5625
+    octave: Rational(2, 1)                              # Octave (2.0)
+  }.freeze
+
+  attr_reader :tonal_center
+
+  def initialize(reference_pitch: :a440, tonal_center: nil)
+    super
+    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
+  end
+
+  def frequency_for(pitch)
+    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
+
+    # Calculate the frequency of the tonal center using equal temperament from reference pitch
+    tonal_center_frequency = calculate_tonal_center_frequency
+
+    # Calculate the interval from the tonal center to the requested pitch
+    interval_from_tonal_center = (pitch - tonal_center).semitones
+
+    # Get the meantone ratio for this interval
+    ratio = ratio_for_interval(interval_from_tonal_center)
+
+    # 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

@@ -0,0 +1,91 @@
+# A module for music rudiments
+module HeadMusic::Rudiment; end
+
+# Pythagorean tuning system based on stacking perfect fifths (3:2 ratio)
+class HeadMusic::Rudiment::Tuning::Pythagorean < HeadMusic::Rudiment::Tuning
+  # Frequency ratios for intervals in Pythagorean tuning (relative to tonic)
+  # Generated by stacking perfect fifths and reducing to within one octave
+  INTERVAL_RATIOS = {
+    unison: Rational(1, 1),
+    minor_second: Rational(256, 243),        # Pythagorean minor second
+    major_second: Rational(9, 8),            # Pythagorean major second
+    minor_third: Rational(32, 27),           # Pythagorean minor third
+    major_third: Rational(81, 64),           # Pythagorean major third (ditone)
+    perfect_fourth: Rational(4, 3),          # Perfect fourth
+    tritone: Rational(729, 512),             # Pythagorean tritone (augmented fourth)
+    perfect_fifth: Rational(3, 2),           # Perfect fifth
+    minor_sixth: Rational(128, 81),          # Pythagorean minor sixth
+    major_sixth: Rational(27, 16),           # Pythagorean major sixth
+    minor_seventh: Rational(16, 9),          # Pythagorean minor seventh
+    major_seventh: Rational(243, 128),       # Pythagorean major seventh
+    octave: Rational(2, 1)                   # Octave
+  }.freeze
+
+  # Additional chromatic intervals for enharmonic equivalents
+  CHROMATIC_RATIOS = {
+    augmented_unison: Rational(2187, 2048),   # Pythagorean augmented unison (sharp)
+    diminished_second: Rational(256, 243)     # Same as minor second in Pythagorean
+  }.freeze
+
+  attr_reader :tonal_center
+
+  def initialize(reference_pitch: :a440, tonal_center: nil)
+    super
+    @tonal_center = HeadMusic::Rudiment::Pitch.get(tonal_center || "C4")
+  end
+
+  def frequency_for(pitch)
+    pitch = HeadMusic::Rudiment::Pitch.get(pitch)
+
+    # Calculate the frequency of the tonal center using equal temperament from reference pitch
+    tonal_center_frequency = calculate_tonal_center_frequency
+
+    # Calculate the interval from the tonal center to the requested pitch
+    interval_from_tonal_center = (pitch - tonal_center).semitones
+
+    # Get the Pythagorean ratio for this interval
+    ratio = ratio_for_interval(interval_from_tonal_center)
+
+    # 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,13 +3,29 @@ 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
 
-  def initialize(reference_pitch: :a440)
+  def self.get(tuning_type = :equal_temperament, **options)
+    case tuning_type.to_s.downcase
+    when "just_intonation", "just", "ji"
+      HeadMusic::Rudiment::Tuning::JustIntonation.new(**options)
+    when "pythagorean", "pythag"
+      HeadMusic::Rudiment::Tuning::Pythagorean.new(**options)
+    when "meantone", "quarter_comma_meantone", "1/4_comma"
+      HeadMusic::Rudiment::Tuning::Meantone.new(**options)
+    when "equal_temperament", "equal", "et", "12tet"
+      new(**options)
+    else
+      new(**options)
+    end
+  end
+
+  def initialize(reference_pitch: :a440, tonal_center: nil)
     @reference_pitch = HeadMusic::Rudiment::ReferencePitch.get(reference_pitch)
+    @tonal_center = tonal_center
   end
 
   def frequency_for(pitch)
@@ -17,5 +33,3 @@ class HeadMusic::Rudiment::Tuning
     reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
   end
 end
-
-# TODO: other tunings

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/annotation.rb

@@ -51,16 +51,16 @@ class HeadMusic::Style::Annotation
     self.class::MESSAGE
   end
 
-  protected
-
   def first_note
-    notes.first()
+    notes.first
   end
 
   def last_note
-    notes.last()
+    notes.last
   end
 
+  protected
+
   def voices
     @voices ||= voice.composition.voices
   end

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

@@ -9,6 +9,22 @@ class HeadMusic::Style::Guidelines::NotesSameLength < HeadMusic::Style::Annotati
     HeadMusic::Style::Mark.for_each(all_wrong_length_notes)
   end
 
+  def first_most_common_rhythmic_value
+    @first_most_common_rhythmic_value ||= begin
+      candidates = most_common_rhythmic_values
+      first_match = notes.detect { |note| candidates.include?(note.rhythmic_value) }
+      first_match&.rhythmic_value
+    end
+  end
+
+  def most_common_rhythmic_values
+    return [] if notes.empty?
+
+    occurrences = occurrences_by_rhythmic_value
+    highest_count = occurrences.values.max
+    occurrences.select { |_rhythmic_value, count| count == highest_count }.keys
+  end
+
   private
 
   def all_wrong_length_notes
@@ -37,22 +53,6 @@ class HeadMusic::Style::Guidelines::NotesSameLength < HeadMusic::Style::Annotati
     notes[0..-2]
   end
 
-  def first_most_common_rhythmic_value
-    @first_most_common_rhythmic_value ||= begin
-      candidates = most_common_rhythmic_values
-      first_match = notes.detect { |note| candidates.include?(note.rhythmic_value) }
-      first_match&.rhythmic_value
-    end
-  end
-
-  def most_common_rhythmic_values
-    return [] if notes.empty?
-
-    occurrences = occurrences_by_rhythmic_value
-    highest_count = occurrences.values.max
-    occurrences.select { |_rhythmic_value, count| count == highest_count }.keys
-  end
-
   def occurrences_by_rhythmic_value
     rhythmic_values.each_with_object(Hash.new(0)) { |value, hash| hash[value] += 1 }
   end

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,34 @@
+# 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, 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
+      # In standard practice, perfect fourth is considered consonant
+      # but contextual would be more accurate
+      HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+    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
+    else
+      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
+      self.class.name.split("::").last.sub(/Tradition$/, "").downcase.gsub(" ", "_").to_sym
+    end
+  end
+end