head_music 8.2.1 → 8.3.0

data/lib/head_music/locales/en.yml

@@ -14,6 +14,98 @@ en:
       minor_seventh: minor seventh
       major_seventh: major seventh
       perfect_octave: perfect octave
+    diatonic_intervals:
+      perfect_unison: perfect unison
+      minor_second: minor second
+      major_second: major second
+      diminished_second: diminished second
+      augmented_second: augmented second
+      doubly_diminished_second: doubly diminished second
+      doubly_augmented_second: doubly augmented second
+      minor_third: minor third
+      major_third: major third
+      diminished_third: diminished third
+      augmented_third: augmented third
+      doubly_diminished_third: doubly diminished third
+      doubly_augmented_third: doubly augmented third
+      perfect_fourth: perfect fourth
+      diminished_fourth: diminished fourth
+      augmented_fourth: augmented fourth
+      doubly_diminished_fourth: doubly diminished fourth
+      doubly_augmented_fourth: doubly augmented fourth
+      perfect_fifth: perfect fifth
+      diminished_fifth: diminished fifth
+      augmented_fifth: augmented fifth
+      doubly_diminished_fifth: doubly diminished fifth
+      doubly_augmented_fifth: doubly augmented fifth
+      minor_sixth: minor sixth
+      major_sixth: major sixth
+      diminished_sixth: diminished sixth
+      augmented_sixth: augmented sixth
+      doubly_diminished_sixth: doubly diminished sixth
+      doubly_augmented_sixth: doubly augmented sixth
+      minor_seventh: minor seventh
+      major_seventh: major seventh
+      diminished_seventh: diminished seventh
+      augmented_seventh: augmented seventh
+      doubly_diminished_seventh: doubly diminished seventh
+      doubly_augmented_seventh: doubly augmented seventh
+      perfect_octave: perfect octave
+      diminished_octave: diminished octave
+      augmented_octave: augmented octave
+      doubly_diminished_octave: doubly diminished octave
+      doubly_augmented_octave: doubly augmented octave
+      minor_ninth: minor ninth
+      major_ninth: major ninth
+      diminished_ninth: diminished ninth
+      augmented_ninth: augmented ninth
+      doubly_diminished_ninth: doubly diminished ninth
+      doubly_augmented_ninth: doubly augmented ninth
+      minor_tenth: minor tenth
+      major_tenth: major tenth
+      diminished_tenth: diminished tenth
+      augmented_tenth: augmented tenth
+      doubly_diminished_tenth: doubly diminished tenth
+      doubly_augmented_tenth: doubly augmented tenth
+      perfect_eleventh: perfect eleventh
+      diminished_eleventh: diminished eleventh
+      augmented_eleventh: augmented eleventh
+      doubly_diminished_eleventh: doubly diminished eleventh
+      doubly_augmented_eleventh: doubly augmented eleventh
+      perfect_twelfth: perfect twelfth
+      diminished_twelfth: diminished twelfth
+      augmented_twelfth: augmented twelfth
+      doubly_diminished_twelfth: doubly diminished twelfth
+      doubly_augmented_twelfth: doubly augmented twelfth
+      minor_thirteenth: minor thirteenth
+      major_thirteenth: major thirteenth
+      diminished_thirteenth: diminished thirteenth
+      augmented_thirteenth: augmented thirteenth
+      doubly_diminished_thirteenth: doubly diminished thirteenth
+      doubly_augmented_thirteenth: doubly augmented thirteenth
+      minor_fourteenth: minor fourteenth
+      major_fourteenth: major fourteenth
+      diminished_fourteenth: diminished fourteenth
+      augmented_fourteenth: augmented fourteenth
+      doubly_diminished_fourteenth: doubly diminished fourteenth
+      doubly_augmented_fourteenth: doubly augmented fourteenth
+      perfect_fifteenth: perfect fifteenth
+      diminished_fifteenth: diminished fifteenth
+      augmented_fifteenth: augmented fifteenth
+      doubly_diminished_fifteenth: doubly diminished fifteenth
+      doubly_augmented_fifteenth: doubly augmented fifteenth
+      minor_sixteenth: minor sixteenth
+      major_sixteenth: major sixteenth
+      diminished_sixteenth: diminished sixteenth
+      augmented_sixteenth: augmented sixteenth
+      doubly_diminished_sixteenth: doubly diminished sixteenth
+      doubly_augmented_sixteenth: doubly augmented sixteenth
+      minor_seventeenth: minor seventeenth
+      major_seventeenth: major seventeenth
+      diminished_seventeenth: diminished seventeenth
+      augmented_seventeenth: augmented seventeenth
+      doubly_diminished_seventeenth: doubly diminished seventeenth
+      doubly_augmented_seventeenth: doubly augmented seventeenth
     clefs:
       alto_clef: alto clef
       baritone_c_clef: baritone C-clef

data/lib/head_music/rudiment/rhythmic_unit.rb

@@ -4,21 +4,45 @@ module HeadMusic::Rudiment; end
 # A rhythmic unit is a rudiment of duration consisting of doublings and divisions of a whole note.
 class HeadMusic::Rudiment::RhythmicUnit
   include HeadMusic::Named
+  include Comparable
 
-  MULTIPLES = ["whole", "double whole", "longa", "maxima"].freeze
-  FRACTIONS = [
+  # Note values longer than a whole note
+  AMERICAN_MULTIPLES_NAMES = [
+    "whole", "double whole", "longa", "maxima"
+  ].freeze
+
+  # Note values from whole note down to very short subdivisions
+  AMERICAN_DIVISIONS_NAMES = [
     "whole", "half", "quarter", "eighth", "sixteenth", "thirty-second",
     "sixty-fourth", "hundred twenty-eighth", "two hundred fifty-sixth"
   ].freeze
 
-  BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima].freeze
-  BRITISH_DIVISION_NAMES = %w[
+  # British terminology for note values longer than a whole note
+  BRITISH_MULTIPLES_NAMES = %w[semibreve breve longa maxima].freeze
+
+  # British terminology for standard note divisions
+  BRITISH_DIVISIONS_NAMES = %w[
     semibreve minim crotchet quaver semiquaver demisemiquaver
     hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver
   ].freeze
 
+  # Notehead symbols used for different note values
+  NOTEHEADS = {
+    maxima: 8.0,
+    longa: 4.0,
+    breve: 2.0,
+    open: [0.5, 1.0],
+    closed: :default
+  }.freeze
+
   def self.for_denominator_value(denominator)
-    get(FRACTIONS[Math.log2(denominator).to_i])
+    return nil unless denominator.is_a?(Numeric) && denominator > 0
+    return nil unless (denominator & (denominator - 1)) == 0  # Check if power of 2
+
+    index = Math.log2(denominator).to_i
+    return nil if index >= AMERICAN_DIVISIONS_NAMES.length
+
+    get(AMERICAN_DIVISIONS_NAMES[index])
   end
 
   attr_reader :numerator, :denominator
@@ -27,7 +51,28 @@ class HeadMusic::Rudiment::RhythmicUnit
     get_by_name(name)
   end
 
+  def self.all
+    @all ||= (AMERICAN_MULTIPLES_NAMES.reverse + AMERICAN_DIVISIONS_NAMES).uniq.map { |name| get(name) }.compact
+  end
+
+  # Check if a name represents a valid rhythmic unit
+  def self.valid_name?(name)
+    normalized = normalize_name(name)
+    all_normalized_names.include?(normalized)
+  end
+
+  def self.all_normalized_names
+    @all_normalized_names ||= (
+      AMERICAN_MULTIPLES_NAMES.map { |n| normalize_name(n) } +
+      AMERICAN_DIVISIONS_NAMES.map { |n| normalize_name(n) } +
+      BRITISH_MULTIPLES_NAMES.map { |n| normalize_name(n) } +
+      BRITISH_DIVISIONS_NAMES.map { |n| normalize_name(n) }
+    ).uniq
+  end
+
   def initialize(canonical_name)
+    raise ArgumentError, "Name cannot be nil or empty" if canonical_name.to_s.strip.empty?
+
     self.name = canonical_name
     @numerator = 2**numerator_exponent
     @denominator = 2**denominator_exponent
@@ -42,65 +87,87 @@ class HeadMusic::Rudiment::RhythmicUnit
   end
 
   def notehead
-    return :maxima if relative_value == 8
-    return :longa if relative_value == 4
-    return :breve if relative_value == 2
-    return :open if [0.5, 1].include? relative_value
+    value = relative_value
+    return :maxima if value == NOTEHEADS[:maxima]
+    return :longa if value == NOTEHEADS[:longa]
+    return :breve if value == NOTEHEADS[:breve]
+    return :open if NOTEHEADS[:open].include?(value)
 
     :closed
   end
 
   def flags
-    FRACTIONS.include?(name) ? [FRACTIONS.index(name) - 2, 0].max : 0
+    AMERICAN_DIVISIONS_NAMES.include?(name) ? [AMERICAN_DIVISIONS_NAMES.index(name) - 2, 0].max : 0
   end
 
   def stemmed?
     relative_value < 1
   end
 
+  # Returns true if this note value is commonly used in modern notation
+  def common?
+    AMERICAN_DIVISIONS_NAMES[0..6].include?(name) || BRITISH_DIVISIONS_NAMES[0..6].include?(name)
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(self.class)
+
+    relative_value <=> other.relative_value
+  end
+
   def british_name
-    if multiple?
-      BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
-    elsif fraction?
-      BRITISH_DIVISION_NAMES[FRACTIONS.index(name)]
-    elsif BRITISH_MULTIPLE_NAMES.include?(name) || BRITISH_DIVISION_NAMES.include?(name)
-      name
+    if has_american_multiple_name?
+      index = AMERICAN_MULTIPLES_NAMES.index(name)
+      return BRITISH_MULTIPLES_NAMES[index] unless index.nil?
+    elsif has_american_division_name?
+      index = AMERICAN_DIVISIONS_NAMES.index(name)
+      return BRITISH_DIVISIONS_NAMES[index] unless index.nil?
+    elsif BRITISH_MULTIPLES_NAMES.include?(name) || BRITISH_DIVISIONS_NAMES.include?(name)
+      return name
     end
+
+    nil # Return nil if no British equivalent found
   end
 
   private_class_method :new
 
+  def self.normalize_name(name)
+    name.to_s.gsub(/\W+/, "_")
+  end
+
   private
 
-  def multiple?
-    MULTIPLES.include?(name)
+  def has_american_multiple_name?
+    AMERICAN_MULTIPLES_NAMES.include?(name)
   end
 
-  def fraction?
-    FRACTIONS.include?(name)
+  def has_american_division_name?
+    AMERICAN_DIVISIONS_NAMES.include?(name)
   end
 
   def numerator_exponent
-    multiples_keys.index(name.gsub(/\W+/, "_")) || british_multiples_keys.index(name.gsub(/\W+/, "_")) || 0
+    normalized_name = self.class.normalize_name(name)
+    multiples_keys.index(normalized_name) || british_multiples_keys.index(normalized_name) || 0
   end
 
   def multiples_keys
-    MULTIPLES.map { |multiple| multiple.gsub(/\W+/, "_") }
+    AMERICAN_MULTIPLES_NAMES.map { |multiple| self.class.normalize_name(multiple) }
   end
 
   def british_multiples_keys
-    BRITISH_MULTIPLE_NAMES.map { |multiple| multiple.gsub(/\W+/, "_") }
+    BRITISH_MULTIPLES_NAMES.map { |multiple| self.class.normalize_name(multiple) }
   end
 
   def denominator_exponent
-    fractions_keys.index(name.gsub(/\W+/, "_")) || british_fractions_keys.index(name.gsub(/\W+/, "_")) || 0
+    normalized_name = self.class.normalize_name(name)
+    fractions_keys.index(normalized_name) || british_fractions_keys.index(normalized_name) || 0
   end
 
   def fractions_keys
-    FRACTIONS.map { |fraction| fraction.gsub(/\W+/, "_") }
+    AMERICAN_DIVISIONS_NAMES.map { |fraction| self.class.normalize_name(fraction) }
   end
 
   def british_fractions_keys
-    BRITISH_DIVISION_NAMES.map { |fraction| fraction.gsub(/\W+/, "_") }
+    BRITISH_DIVISIONS_NAMES.map { |fraction| self.class.normalize_name(fraction) }
   end
 end

data/lib/head_music/rudiment/scale_degree.rb

@@ -38,11 +38,16 @@ class HeadMusic::Rudiment::ScaleDegree
   end
 
   def <=>(other)
-    if other.is_a?(HeadMusic::Rudiment::ScaleDegree)
+    case other
+    when HeadMusic::Rudiment::ScaleDegree
       [degree, alteration_semitones] <=> [other.degree, other.alteration_semitones]
-    else
-      # TODO: Improve this
+    when Numeric
+      degree <=> other
+    when String
       to_s <=> other.to_s
+    else
+      # If we can't meaningfully compare, return nil (Ruby standard)
+      nil
     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

@@ -8,8 +8,24 @@ class HeadMusic::Rudiment::Tuning
 
   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/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/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "8.2.1"
+  VERSION = "8.3.0"
 end