head_music 8.3.0 → 11.0.0

data/lib/head_music/analysis/diatonic_interval.rb

@@ -57,16 +57,17 @@ class HeadMusic::Analysis::DiatonicInterval
 
   alias_method :to_i, :semitones
 
-  # Override Named module methods to use computed name from naming
+  # Override Named module method to try I18n and fall back to computed name
   def name(locale_code: nil)
     if locale_code
-      # Try to get translation from locale files
-      name_key = naming.name.downcase.gsub(" ", "_").to_sym
-      translation = I18n.translate(name_key, scope: "head_music.diatonic_intervals", locale: locale_code, default: nil)
-      translation || naming.name
-    else
-      naming.name
+      name_key = HeadMusic::Utilities::HashKey.for(naming.name)
+      if I18n.backend.translations[locale_code]
+        locale_data = I18n.backend.translations[locale_code][:head_music] || {}
+        return locale_data[:diatonic_intervals][name_key] if locale_data.dig(:diatonic_intervals, name_key)
+        return locale_data[:chromatic_intervals][name_key] if locale_data.dig(:chromatic_intervals, name_key)
+      end
     end
+    naming.name
   end
 
   def to_s
@@ -111,26 +112,39 @@ class HeadMusic::Analysis::DiatonicInterval
   alias_method :invert, :inversion
 
   def consonance(style = :standard_practice)
-    consonance_for_perfect(style) ||
-      consonance_for_major_and_minor ||
-      HeadMusic::Rudiment::Consonance.get(:dissonant)
+    consonance_analysis(style).consonance
   end
 
   def consonance?(style = :standard_practice)
-    consonance(style).perfect? || consonance(style).imperfect?
+    consonance(style).consonant?
+  end
+
+  def consonant?(style = :standard_practice)
+    consonance_analysis(style).consonant?
   end
-  alias_method :consonant?, :consonance?
 
   def perfect_consonance?(style = :standard_practice)
-    consonance(style).perfect?
+    consonance_analysis(style).perfect_consonance?
   end
 
   def imperfect_consonance?(style = :standard_practice)
-    consonance(style).imperfect?
+    consonance_analysis(style).imperfect_consonance?
   end
 
   def dissonance?(style = :standard_practice)
-    consonance(style).dissonant?
+    consonance_analysis(style).dissonant?
+  end
+
+  def dissonant?(style = :standard_practice)
+    consonance_analysis(style).dissonant?
+  end
+
+  def consonance_analysis(style = :standard_practice)
+    HeadMusic::Analysis::IntervalConsonance.new(self, style)
+  end
+
+  def consonance_classification(style: :standard_practice)
+    consonance_analysis(style).classification
   end
 
   def above(pitch)
@@ -181,16 +195,4 @@ class HeadMusic::Analysis::DiatonicInterval
   def naming
     @naming ||= Naming.new(number: number, semitones: semitones)
   end
-
-  def consonance_for_perfect(style = :standard_practice)
-    HeadMusic::Rudiment::Consonance.get(dissonant_fourth?(style) ? :dissonant : :perfect) if perfect?
-  end
-
-  def consonance_for_major_and_minor
-    HeadMusic::Rudiment::Consonance.get((third_or_compound? || sixth_or_compound?) ? :imperfect : :dissonant) if major? || minor?
-  end
-
-  def dissonant_fourth?(style = :standard_practice)
-    fourth_or_compound? && style == :two_part_harmony
-  end
 end

data/lib/head_music/analysis/dyad.rb

@@ -0,0 +1,229 @@
+# A module for musical analysis
+module HeadMusic::Analysis; end
+
+# A Dyad is a two-pitch combination that can imply various chords.
+# It analyzes the harmonic implications of two pitches sounding together.
+class HeadMusic::Analysis::Dyad
+  attr_reader :pitch1, :pitch2, :key
+
+  def initialize(pitch1, pitch2, key: nil)
+    @pitch1, @pitch2 = [
+      HeadMusic::Rudiment::Pitch.get(pitch1),
+      HeadMusic::Rudiment::Pitch.get(pitch2)
+    ].sort
+    @key = key ? HeadMusic::Rudiment::Key.get(key) : nil
+  end
+
+  def interval
+    @interval ||= HeadMusic::Analysis::DiatonicInterval.new(lower_pitch, upper_pitch)
+  end
+
+  def pitches
+    [pitch1, pitch2]
+  end
+
+  def lower_pitch
+    @lower_pitch ||= [pitch1, pitch2].min
+  end
+
+  def upper_pitch
+    @upper_pitch ||= [pitch1, pitch2].max
+  end
+
+  def possible_trichords
+    @possible_trichords ||= begin
+      trichords = generate_possible_trichords
+      trichords = filter_by_key(trichords) if key
+      sort_by_diatonic_agreement(trichords)
+    end
+  end
+
+  def possible_triads
+    @possible_triads ||= possible_trichords.select(&:triad?)
+  end
+
+  def possible_seventh_chords
+    @possible_seventh_chords ||= begin
+      seventh_chords = generate_possible_seventh_chords
+      seventh_chords = filter_by_key(seventh_chords) if key
+      sort_by_diatonic_agreement(seventh_chords)
+    end
+  end
+
+  def enharmonic_respellings
+    @enharmonic_respellings ||= generate_enharmonic_respellings
+  end
+
+  def to_s
+    "#{pitch1} - #{pitch2}"
+  end
+
+  def method_missing(method_name, *args, &block)
+    respond_to_missing?(method_name) ? interval.send(method_name, *args, &block) : super
+  end
+
+  def respond_to_missing?(method_name, *_args)
+    interval.respond_to?(method_name)
+  end
+
+  private
+
+  def generate_possible_trichords
+    trichords = []
+    pitch_classes = [lower_pitch.pitch_class, upper_pitch.pitch_class]
+
+    HeadMusic::Rudiment::Spelling::CHROMATIC_SPELLINGS.each do |root_spelling|
+      root_pitch = HeadMusic::Rudiment::Pitch.get("#{root_spelling}4")
+
+      # Try all common trichord types from this root
+      trichord_intervals = [
+        %w[M3 P5],   # major triad
+        %w[m3 P5],   # minor triad
+        %w[m3 d5],   # diminished triad
+        %w[M3 A5],   # augmented triad
+        %w[P4 P5],   # sus4 (not a triad)
+        %w[M2 P5]    # sus2 (not a triad)
+      ]
+
+      trichord_intervals.each do |intervals|
+        trichord_pitches = [root_pitch]
+
+        # Each interval is FROM THE ROOT, not consecutive
+        intervals.each do |interval_name|
+          interval = HeadMusic::Analysis::DiatonicInterval.get(interval_name)
+          next_pitch = interval.above(root_pitch)
+          trichord_pitches << next_pitch
+        end
+
+        pitch_collection = HeadMusic::Analysis::PitchCollection.new(trichord_pitches)
+        trichord_pitch_classes = pitch_collection.pitch_classes
+
+        # Check if this trichord contains both pitches from our dyad
+        if pitch_classes.all? { |pc| trichord_pitch_classes.include?(pc) }
+          trichords << pitch_collection
+        end
+      end
+    end
+
+    trichords.uniq { |t| t.pitch_classes.sort.map(&:to_i) }
+  end
+
+  def generate_possible_seventh_chords
+    seventh_chords = []
+    pitch_classes = [lower_pitch.pitch_class, upper_pitch.pitch_class]
+
+    HeadMusic::Rudiment::Spelling::CHROMATIC_SPELLINGS.each do |root_spelling|
+      root_pitch = HeadMusic::Rudiment::Pitch.get("#{root_spelling}4")
+
+      # Try all common seventh chord types from this root
+      seventh_chord_intervals = [
+        %w[M3 P5 M7],   # major seventh
+        %w[M3 P5 m7],   # dominant seventh (major-minor)
+        %w[m3 P5 m7],   # minor seventh
+        %w[m3 P5 M7],   # minor-major seventh
+        %w[m3 d5 m7],   # half-diminished seventh
+        %w[m3 d5 d7],   # diminished seventh
+        %w[M2 M3 P5 m7], # dominant ninth
+        %w[m2 M3 P5 m7], # dominant minor ninth
+        %w[M2 m3 P5 m7], # minor ninth
+        %w[M2 M3 P5 M7]  # major ninth
+      ]
+
+      seventh_chord_intervals.each do |intervals|
+        chord_pitches = [root_pitch]
+
+        # Each interval is FROM THE ROOT, not consecutive
+        intervals.each do |interval_name|
+          interval = HeadMusic::Analysis::DiatonicInterval.get(interval_name)
+          next_pitch = interval.above(root_pitch)
+          chord_pitches << next_pitch
+        end
+
+        pitch_collection = HeadMusic::Analysis::PitchCollection.new(chord_pitches)
+        chord_pitch_classes = pitch_collection.pitch_classes
+
+        # Check if this chord contains both pitches from our dyad
+        if pitch_classes.all? { |pc| chord_pitch_classes.include?(pc) }
+          seventh_chords << pitch_collection
+        end
+      end
+    end
+
+    seventh_chords.uniq { |c| c.pitch_classes.sort.map(&:to_i) }
+  end
+
+  def filter_by_key(pitch_collections)
+    return pitch_collections unless key
+
+    diatonic_spellings = key.scale.spellings
+
+    pitch_collections.select do |pitch_collection|
+      pitch_collection.pitches.all? { |pitch| diatonic_spellings.include?(pitch.spelling) }
+    end
+  end
+
+  def sort_by_diatonic_agreement(pitch_collections)
+    return pitch_collections unless key
+
+    diatonic_spellings = key.scale.spellings
+
+    pitch_collections.sort_by do |pitch_collection|
+      # Count how many pitches match diatonic spellings (lower is better for sort)
+      diatonic_count = pitch_collection.pitches.count { |pitch| diatonic_spellings.include?(pitch.spelling) }
+      -diatonic_count # Negative so higher counts come first
+    end
+  end
+
+  def generate_enharmonic_respellings
+    respellings = []
+
+    # Get enharmonic equivalents for each pitch
+    pitch1_equivalents = get_enharmonic_equivalents(pitch1)
+    pitch2_equivalents = get_enharmonic_equivalents(pitch2)
+
+    # Generate all combinations
+    pitch1_equivalents.each do |p1|
+      pitch2_equivalents.each do |p2|
+        # Skip the original combination
+        next if p1.spelling == pitch1.spelling && p2.spelling == pitch2.spelling
+
+        # Create new dyad with same key context
+        respellings << self.class.new(p1, p2, key: key)
+      end
+    end
+
+    respellings
+  end
+
+  def get_enharmonic_equivalents(pitch)
+    equivalents = [pitch]
+
+    # Get common enharmonic spellings
+    pitch_class = pitch.pitch_class
+    letter_names = HeadMusic::Rudiment::LetterName.all
+
+    letter_names.each do |letter_name|
+      [-2, -1, 0, 1, 2].each do |alteration_semitones|
+        spelling = HeadMusic::Rudiment::Spelling.get("#{letter_name}#{alteration_sign(alteration_semitones)}")
+        next unless spelling
+
+        if spelling.pitch_class == pitch_class
+          equivalent_pitch = HeadMusic::Rudiment::Pitch.fetch_or_create(spelling, pitch.register)
+          equivalents << equivalent_pitch unless equivalents.any? { |p| p.spelling == spelling }
+        end
+      end
+    end
+
+    equivalents
+  end
+
+  def alteration_sign(semitones)
+    case semitones
+    when -2 then "bb"
+    when -1 then "b"
+    when 0 then ""
+    when 1 then "#"
+    when 2 then "##"
+    end
+  end
+end

data/lib/head_music/analysis/interval_consonance.rb

@@ -0,0 +1,51 @@
+# Analysis class that combines an interval with a style tradition to determine consonance
+class HeadMusic::Analysis::IntervalConsonance
+  attr_reader :interval, :style_tradition
+
+  def initialize(interval, style_tradition = HeadMusic::Style::ModernTradition.new)
+    @interval = interval
+    @style_tradition = style_tradition.is_a?(HeadMusic::Style::Tradition) ?
+                       style_tradition :
+                       HeadMusic::Style::Tradition.get(style_tradition)
+  end
+
+  def classification
+    @classification ||= style_tradition.consonance_classification(interval)
+  end
+
+  def consonance
+    @consonance ||= HeadMusic::Rudiment::Consonance.get(classification)
+  end
+
+  def consonant?
+    [HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE, HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE].include?(classification)
+  end
+
+  def dissonant?
+    [HeadMusic::Rudiment::Consonance::MILD_DISSONANCE, HeadMusic::Rudiment::Consonance::HARSH_DISSONANCE, HeadMusic::Rudiment::Consonance::DISSONANCE].include?(classification)
+  end
+
+  def contextual?
+    classification == HeadMusic::Rudiment::Consonance::CONTEXTUAL
+  end
+
+  def perfect_consonance?
+    classification == HeadMusic::Rudiment::Consonance::PERFECT_CONSONANCE
+  end
+
+  def imperfect_consonance?
+    classification == HeadMusic::Rudiment::Consonance::IMPERFECT_CONSONANCE
+  end
+
+  def mild_dissonance?
+    classification == HeadMusic::Rudiment::Consonance::MILD_DISSONANCE
+  end
+
+  def harsh_dissonance?
+    classification == HeadMusic::Rudiment::Consonance::HARSH_DISSONANCE
+  end
+
+  def dissonance?
+    classification == HeadMusic::Rudiment::Consonance::DISSONANCE
+  end
+end

data/lib/head_music/analysis/melodic_interval.rb

@@ -62,7 +62,7 @@ class HeadMusic::Analysis::MelodicInterval
     combined_pitches = (pitches + other_interval.pitches).uniq
     return false if combined_pitches.length < 3
 
-    HeadMusic::Analysis::PitchSet.new(combined_pitches).consonant_triad?
+    HeadMusic::Analysis::PitchCollection.new(combined_pitches).consonant_triad?
   end
 
   def method_missing(method_name, *args, &block)

data/lib/head_music/analysis/pitch_class_set.rb

@@ -2,7 +2,7 @@
 module HeadMusic::Analysis; end
 
 # A PitchClassSet represents a pitch-class set or pitch collection.
-# See also: PitchSet, PitchClass
+# See also: PitchCollection, PitchClass
 class HeadMusic::Analysis::PitchClassSet
   attr_reader :pitch_classes
 
@@ -23,7 +23,7 @@ class HeadMusic::Analysis::PitchClassSet
   end
 
   def equivalent?(other)
-    pitch_classes.sort == other.pitch_classes.sort
+    pitch_classes == other.pitch_classes
   end
 
   def size
@@ -31,52 +31,149 @@ class HeadMusic::Analysis::PitchClassSet
   end
 
   def monochord?
-    pitch_classes.length == 1
+    size == 1
   end
   alias_method :monad?, :monochord?
 
   def dichord?
-    pitch_classes.length == 2
+    size == 2
   end
   alias_method :dyad?, :dichord?
 
   def trichord?
-    pitch_classes.length == 3
+    size == 3
   end
 
   def tetrachord?
-    pitch_classes.length == 4
+    size == 4
   end
 
   def pentachord?
-    pitch_classes.length == 5
+    size == 5
   end
 
   def hexachord?
-    pitch_classes.length == 6
+    size == 6
   end
 
   def heptachord?
-    pitch_classes.length == 7
+    size == 7
   end
 
   def octachord?
-    pitch_classes.length == 8
+    size == 8
   end
 
   def nonachord?
-    pitch_classes.length == 9
+    size == 9
   end
 
   def decachord?
-    pitch_classes.length == 10
+    size == 10
   end
 
   def undecachord?
-    pitch_classes.length == 11
+    size == 11
   end
 
   def dodecachord?
-    pitch_classes.length == 12
+    size == 12
+  end
+
+  # Returns the inversion of the pitch class set
+  # Inversion maps each pitch class to its inverse around 0
+  # For pitch class n, the inversion is (12 - n) mod 12
+  def inversion
+    @inversion ||=
+      self.class.new(
+        pitch_classes.map { |pc| (12 - pc.to_i) % 12 }
+      )
+  end
+
+  # Returns the normal form of the pitch class set
+  # The normal form is the most compact rotation of the set
+  # Algorithm:
+  # 1. Generate all rotations of the pitch class set
+  # 2. For each rotation, calculate the span (difference between first and last)
+  # 3. Choose the rotation with the smallest span
+  # 4. If there's a tie, choose the one with the smallest intervals from the left
+  def normal_form
+    return self if size <= 1
+
+    @rotations ||= generate_rotations
+    @most_compact_rotation ||= find_most_compact_rotation(@rotations)
+
+    self.class.new(@most_compact_rotation)
+  end
+
+  # Returns the prime form of the pitch class set
+  # The prime form is the most compact form among the normal form and its inversion
+  # Algorithm:
+  # 1. Find the normal form of the original set
+  # 2. Find the normal form of the inverted set
+  # 3. Compare and choose the most compact one
+  # 4. Transpose to start at 0
+  def prime_form
+    @prime_form ||= begin
+      # Handle edge cases
+      return self if size.zero?
+      return self.class.new([0]) if size == 1
+
+      normal = normal_form.pitch_classes
+      inverted_normal = inversion.normal_form.pitch_classes
+
+      # Compare which is more compact
+      chosen = compare_forms(normal, inverted_normal)
+
+      # Transpose to start at 0
+      transposed = transpose_to_zero(chosen)
+
+      self.class.new(transposed)
+    end
+  end
+
+  private
+
+  # Generate all rotations of the pitch class set
+  def generate_rotations
+    return [pitch_classes] if size <= 1
+
+    numbers = pitch_classes.map(&:to_i)
+    (0...size).map do |i|
+      rotation = numbers.rotate(i)
+      # Normalize each rotation to start from the first element
+      first = rotation.first
+      rotation.map { |n| (n - first) % 12 }
+    end
+  end
+
+  # Find the most compact rotation
+  # Returns the rotation with the smallest span
+  # In case of tie, prefer the one with smaller intervals from the left
+  def find_most_compact_rotation(rotations)
+    rotations.min_by do |rotation|
+      # Create a comparison key: [span, intervals from left]
+      [rotation.last] + rotation
+    end
+  end
+
+  # Compare two normal forms and return the more compact one
+  # If equal, return the first one
+  def compare_forms(form1, form2)
+    normalized1 = transpose_to_zero(form1).map(&:to_i)
+    normalized2 = transpose_to_zero(form2).map(&:to_i)
+
+    # Compare lexicographically element by element
+    comparison = normalized1 <=> normalized2
+    (comparison && comparison <= 0) ? form1 : form2
+  end
+
+  # Transpose a set of pitch classes to start at 0
+  def transpose_to_zero(pcs)
+    return pcs if pcs.empty?
+
+    numbers = pcs.map(&:to_i)
+    first = numbers.first
+    numbers.map { |n| HeadMusic::Rudiment::PitchClass.get((n - first) % 12) }
   end
 end

data/lib/head_music/analysis/{pitch_set.rb → pitch_collection.rb}

@@ -1,9 +1,11 @@
 # A module for musical analysis
 module HeadMusic::Analysis; end
 
-# A PitchSet is a collection of one or more pitches.
+# A PitchCollection is a collection of one or more pitches with specific registers.
+# In music theory, "pitch collection" refers to an ordered or unordered group of actual pitches,
+# as distinct from a "pitch-class set" which abstracts away register and octave equivalence.
 # See also: PitchClassSet
-class HeadMusic::Analysis::PitchSet
+class HeadMusic::Analysis::PitchCollection
   TERTIAN_SONORITIES = {
     implied_triad: [3],
     triad: [3, 5],
@@ -35,7 +37,7 @@ class HeadMusic::Analysis::PitchSet
   end
 
   def reduction
-    @reduction ||= HeadMusic::Analysis::PitchSet.new(reduction_pitches)
+    @reduction ||= HeadMusic::Analysis::PitchCollection.new(reduction_pitches)
   end
 
   def diatonic_intervals
@@ -67,13 +69,13 @@ class HeadMusic::Analysis::PitchSet
   def invert
     inverted_pitch = pitches[0] + HeadMusic::Analysis::DiatonicInterval.get("perfect octave")
     new_pitches = pitches.drop(1) + [inverted_pitch]
-    HeadMusic::Analysis::PitchSet.new(new_pitches)
+    HeadMusic::Analysis::PitchCollection.new(new_pitches)
   end
 
   def uninvert
     inverted_pitch = pitches[-1] - HeadMusic::Analysis::DiatonicInterval.get("perfect octave")
     new_pitches = [inverted_pitch] + pitches[0..-2]
-    HeadMusic::Analysis::PitchSet.new(new_pitches)
+    HeadMusic::Analysis::PitchCollection.new(new_pitches)
   end
 
   def bass_pitch
@@ -187,6 +189,10 @@ class HeadMusic::Analysis::PitchSet
     @scale_degrees_above_bass_pitch ||= diatonic_intervals_above_bass_pitch.map(&:simple_number).sort - [8]
   end
 
+  def sonority
+    @sonority ||= HeadMusic::Analysis::Sonority.new(self)
+  end
+
   private
 
   def reduction_pitches

data/lib/head_music/analysis/sonority.rb

@@ -27,17 +27,55 @@ class HeadMusic::Analysis::Sonority
     quartal_chord: %w[P4 m7]
   }.freeze
 
-  attr_reader :pitch_set
+  DEFAULT_ROOT = "C4"
+
+  # Factory method to get a sonority by identifier
+  # Returns a Sonority with pitches starting at the default root (C4)
+  #
+  # @param identifier [Symbol, String] the sonority identifier (e.g., :major_triad)
+  # @param root [String] the root pitch (default: "C4")
+  # @param inversion [Integer] the inversion number (default: 0 for root position)
+  # @return [Sonority, nil] the sonority object, or nil if identifier not found
+  def self.get(identifier, root: DEFAULT_ROOT, inversion: 0)
+    identifier = identifier.to_sym
+    return nil unless SONORITIES.key?(identifier)
+
+    root_pitch = HeadMusic::Rudiment::Pitch.get(root)
+    interval_shorthands = SONORITIES[identifier]
+
+    # Build pitches: root + intervals above root
+    pitches = [root_pitch] + interval_shorthands.map do |shorthand|
+      interval = HeadMusic::Analysis::DiatonicInterval.get(shorthand)
+      interval.above(root_pitch)
+    end
+
+    pitch_collection = HeadMusic::Analysis::PitchCollection.new(pitches)
+
+    # Apply inversions if requested
+    inversion.times do
+      pitch_collection = pitch_collection.invert
+    end
+
+    new(pitch_collection)
+  end
+
+  # Returns all available sonority identifiers
+  # @return [Array<Symbol>] array of sonority identifiers
+  def self.identifiers
+    SONORITIES.keys
+  end
+
+  attr_reader :pitch_collection
 
-  delegate :reduction, to: :pitch_set
-  delegate :empty?, :empty_set?, to: :pitch_set
-  delegate :monochord?, :monad, :dichord?, :dyad?, :trichord?, :tetrachord?, :pentachord?, :hexachord?, to: :pitch_set
-  delegate :heptachord?, :octachord?, :nonachord?, :decachord?, :undecachord?, :dodecachord?, to: :pitch_set
-  delegate :pitch_class_set, :pitch_class_set_size, to: :pitch_set
-  delegate :scale_degrees_above_bass_pitch, to: :pitch_set
+  delegate :reduction, to: :pitch_collection
+  delegate :empty?, :empty_set?, to: :pitch_collection
+  delegate :monochord?, :monad, :dichord?, :dyad?, :trichord?, :tetrachord?, :pentachord?, :hexachord?, to: :pitch_collection
+  delegate :heptachord?, :octachord?, :nonachord?, :decachord?, :undecachord?, :dodecachord?, to: :pitch_collection
+  delegate :pitch_class_set, :pitch_class_set_size, to: :pitch_collection
+  delegate :scale_degrees_above_bass_pitch, to: :pitch_collection
 
-  def initialize(pitch_set)
-    @pitch_set = pitch_set
+  def initialize(pitch_collection)
+    @pitch_collection = pitch_collection
     identifier
   end
 
@@ -75,7 +113,7 @@ class HeadMusic::Analysis::Sonority
 
   def consonant?
     @consonant ||=
-      pitch_set.reduction_diatonic_intervals.all?(&:consonant?) &&
+      pitch_collection.reduction_diatonic_intervals.all?(&:consonant?) &&
       root_position.diatonic_intervals_above_bass_pitch.all?(&:consonant?)
   end
 
@@ -117,8 +155,8 @@ class HeadMusic::Analysis::Sonority
   end
 
   def ==(other)
-    other = HeadMusic::Analysis::PitchSet.new(other) if other.is_a?(Array)
-    other = self.class.new(other) if other.is_a?(HeadMusic::Analysis::PitchSet)
+    other = HeadMusic::Analysis::PitchCollection.new(other) if other.is_a?(Array)
+    other = self.class.new(other) if other.is_a?(HeadMusic::Analysis::PitchCollection)
     identifier == other.identifier
   end
 end