head_music 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5e3afc9754608ddd1d1c10b191f356d4c200733ebfd9e9294693309d7ab53d9
-  data.tar.gz: f92fbe212261872b48e41d1189289f7a0b9aea7643e060a3e96ed223746f1089
+  metadata.gz: 5ce84c55ee00f24b71bcedf973bd5cab1c1d9a7150ebc92bb0508ccd40c3038d
+  data.tar.gz: '084c59660f40b4cc8746499939a38086d4df92180e4b75c37272d4835092fea0'
 SHA512:
-  metadata.gz: 30fac39ee9b758610839343fb7e879ec5422485a83240be3b535be261fc5e31d9f6a2f66c8a34523f90bb95c9f6c3c836ba1a404d07a40634bc2963a1cb584c3
-  data.tar.gz: ef1240d4dcc7b9d159967a1dcad186867c2dc1f7cac8e33df295d77452bb75d0a1888d9d3a99800aeff60d7a00dca94d7a9ece30d8190769ebcacffbceccedf5
+  metadata.gz: 91a8fc2f37f9d6b83be92b4b8d5a5f1efddaac4893202df14255fc456d6a60fa74807b01c6efa6e4f72013e6a33e02884a9685af904ee8b5e7ce07f75e08a939
+  data.tar.gz: 0a34937e07c4742d031055ccc5661a15b3373c4b86dbd02b12fe91df7b2c87e50f1c767e7d34119e4184fc76b103f74eb3fdb3b7735c94cb34c9cb97d3270d19

data/TODO.md

@@ -1,18 +1,113 @@
 # TODO
 
+Disambiguate PitchSet and Sonority
+
+Sonority should be a name for a specific set of intervals
+Sonority.get(identifier)
+Sonority.for(pitch_set)
+Sonority.pitch_set_for(root_pitch:, inversion:)
+
+    class PitchSet
+      def sonority
+        @sonority ||= Sonority.for(self)
+      end
+    end
+
+
+
+open consonance (P5 P8)
+soft consonance (m3 M3 m6 M6)
+mild dissonance (M2 m7)
+sharp dissonance (m2 M7)
+
+P4 (consonant or dissonant)
+T (neutral or restless)
+
+Sets
+DurationSet?
+
+
+Make new analysis classes:
+Dyad
+  .interval
+  .implied_triad (if a third)
+  .possible_triads
+    - returns major and minor if a perfect fifth
+    - returns minor and diminished if minor third
+    - returns major and augmented if major third
+    - returns augmented if augmented fifth
+    - returns diminished if diminished fifth
+    - should it take into account enharmonics? I think yes.
+  .possible_seventh_chords
+    - as above, with either seventh added
+    - returns 3rd inversion if second
+  .possible_chords
+    possible_triads + possible_seventh_chords
+  .possible_enharmonic_triads
+  .possible_enharmonic_seventh_chords
+  .possible_enharmonic_chords
+
+the dyad will be super helpful in analyzing two-part counterpoint.
+
+Triad
+SeventhChord
+Don't need anything beyond seventh chords to analyze pre-Romantic music.
+
+
 ## User stories
 
+
 ### Done
 
+    As a developer
+    When instantiating a DiatonicInterval
+    When passing an abbreviation, such as 'P5' or 'm2'
+    I want to receive that instance.
+
     As a developer
     Given a pitch
-    I want to be able to add a functional interval to get another pitch.
+    I want to be able to add a diatonic interval to get another pitch.
 
-FunctionalInterval
+DiatonicInterval
   - def above(pitch) -> pitch
-FunctionalInterval
+DiatonicInterval
   - def below(pitch) -> pitch
 
 Pitch addition and subtraction
   - define `Pitch#+`, `Pitch#-`
-  - use FunctionalInterval methods
+  - use DiatonicInterval methods
+
+PitchSet
+
+A PitchSet is unlike a PitchClassSet in that the pitches have spellings with octaves rather than Spellings only or octave-less 0-11 designations.
+
+PitchClassSet
+.size?
+.monad?
+.dyad?
+.triad? (must be stacked thirds to be a 'triad')
+.trichord? (all 3-pitch sets)
+
+Should every group of pitches have one or more strategies for describing it? Such as Dyad?
+
+Set (superclass?)
+PitchSet
+  EmptySet
+  Monad
+  Dyad
+  Trichord (or Triad)
+    - triad?
+  Tetrachord (or Tetrad)
+    - seventh_chord?
+  Pentachord (or Pentad)
+  Hexachord (or Hexad)
+  Heptachords (or Heptad or, sometimes, mixing Latin and Greek roots, "Septachord")
+  Octachords (Octad)
+  Nonachords (Nonad)
+  Decachords (Decad)
+  Undecachords
+  Dodecachord
+
+PitchClassSet
+  .normal_form? (most compact)
+  .prime_form (most compact normal form of the original or any inversion)

data/lib/head_music.rb

@@ -20,15 +20,14 @@ require 'head_music/utilities/hash_key'
 require 'head_music/named_rudiment'
 
 # rudiments
-require 'head_music/chord'
+require 'head_music/chromatic_interval'
 require 'head_music/circle'
 require 'head_music/clef'
 require 'head_music/consonance'
-require 'head_music/functional_interval'
+require 'head_music/diatonic_interval'
 require 'head_music/grand_staff'
 require 'head_music/harmonic_interval'
 require 'head_music/instrument'
-require 'head_music/interval'
 require 'head_music/key_signature'
 require 'head_music/letter_name'
 require 'head_music/melodic_interval'
@@ -39,13 +38,17 @@ require 'head_music/pitch'
 require 'head_music/pitch/enharmonic_equivalence'
 require 'head_music/pitch/octave_equivalence'
 require 'head_music/pitch_class'
+require 'head_music/pitch_class_set'
+require 'head_music/pitch_set'
 require 'head_music/quality'
+require 'head_music/reference_pitch'
 require 'head_music/rhythm'
 require 'head_music/rhythmic_unit'
 require 'head_music/scale'
 require 'head_music/scale_degree'
 require 'head_music/scale_type'
 require 'head_music/sign'
+require 'head_music/sonority'
 require 'head_music/spelling'
 require 'head_music/staff'
 require 'head_music/tuning'

data/lib/head_music/{interval.rb → chromatic_interval.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # An interval is the distance between two pitches.
-class HeadMusic::Interval
+class HeadMusic::ChromaticInterval
   include Comparable
 
   private_class_method :new
@@ -25,7 +25,7 @@ class HeadMusic::Interval
   end
 
   def simple
-    HeadMusic::Interval.get(semitones % 12)
+    HeadMusic::ChromaticInterval.get(semitones % 12)
   end
 
   def simple?
@@ -40,12 +40,15 @@ class HeadMusic::Interval
     semitones
   end
 
+  # diatonic set theory
+  alias specific_interval semitones
+
   def +(other)
-    HeadMusic::Interval.get(to_i + other.to_i)
+    HeadMusic::ChromaticInterval.get(to_i + other.to_i)
   end
 
   def -(other)
-    HeadMusic::Interval.get((to_i - other.to_i).abs)
+    HeadMusic::ChromaticInterval.get((to_i - other.to_i).abs)
   end
 
   def <=>(other)

data/lib/head_music/circle.rb

@@ -20,8 +20,8 @@ class HeadMusic::Circle
   attr_reader :interval, :pitch_classes
 
   def initialize(interval)
-    @interval = HeadMusic::Interval.get(interval.to_i)
-    @pitch_classes = pitch_classes_by_interval(interval)
+    @interval = interval.to_i
+    @pitch_classes = pitch_classes_by_interval
   end
 
   def index(pitch_class)
@@ -32,7 +32,7 @@ class HeadMusic::Circle
 
   private
 
-  def pitch_classes_by_interval(interval)
+  def pitch_classes_by_interval
     [HeadMusic::PitchClass.get(0)].tap do |list|
       loop do
         next_pitch_class = list.last + interval

data/lib/head_music/content/placement.rb

@@ -33,7 +33,7 @@ class HeadMusic::Placement
   end
 
   def to_s
-    "#{rhythmic_value} #{pitch.presence || 'rest'} at #{position}"
+    "#{rhythmic_value} #{pitch || 'rest'} at #{position}"
   end
 
   private

data/lib/head_music/content/voice.rb

@@ -54,7 +54,7 @@ class HeadMusic::Voice
   end
 
   def range
-    HeadMusic::FunctionalInterval.new(lowest_pitch, highest_pitch)
+    HeadMusic::DiatonicInterval.new(lowest_pitch, highest_pitch)
   end
 
   def melodic_intervals

data/lib/head_music/{functional_interval.rb → diatonic_interval.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# A functional interval is the distance between two spelled pitches.
-class HeadMusic::FunctionalInterval
+# A diatonic interval is the distance between two spelled pitches.
+class HeadMusic::DiatonicInterval
   include Comparable
 
   NUMBER_NAMES = %w[
@@ -31,6 +31,14 @@ class HeadMusic::FunctionalInterval
     seventeenth: { major: 28 },
   }.freeze
 
+  QUALITY_ABBREVIATIONS = {
+    P: 'perfect',
+    M: 'major',
+    m: 'minor',
+    d: 'diminished',
+    A: 'augmented',
+  }.freeze
+
   attr_reader :lower_pitch, :higher_pitch
 
   delegate :to_s, to: :name
@@ -41,7 +49,7 @@ class HeadMusic::FunctionalInterval
     attr_reader :identifier
 
     def initialize(identifier)
-      @identifier = identifier
+      @identifier = expand(identifier)
     end
 
     def words
@@ -63,6 +71,20 @@ class HeadMusic::FunctionalInterval
     def higher_letter
       HeadMusic::Pitch.middle_c.letter_name.steps_up(steps)
     end
+
+    def expand(identifier)
+      if /[A-Z]\d{1,2}/i.match?(identifier)
+        number = NUMBER_NAMES[identifier.gsub(/[A-Z]/i, '').to_i - 1]
+        return [quality_for(identifier[0]), number].join('_').to_sym
+      end
+      identifier
+    end
+
+    def quality_for(abbreviation)
+      QUALITY_ABBREVIATIONS[abbreviation.to_sym] ||
+        QUALITY_ABBREVIATIONS[abbreviation.upcase.to_sym] ||
+        QUALITY_ABBREVIATIONS[abbreviation.downcase.to_sym]
+    end
   end
 
   # Accepts a name and a quality and returns the number of semitones
@@ -70,7 +92,7 @@ class HeadMusic::FunctionalInterval
     attr_reader :count
 
     def initialize(name, quality_name)
-      @count ||= Semitones.degree_quality_semitones.dig(name, quality_name)
+      @count = Semitones.degree_quality_semitones.dig(name, quality_name)
     end
 
     def self.degree_quality_semitones
@@ -167,6 +189,10 @@ class HeadMusic::FunctionalInterval
       number - 1
     end
 
+    def simple_steps
+      steps % 7
+    end
+
     private
 
     def octave_equivalent?
@@ -246,7 +272,7 @@ class HeadMusic::FunctionalInterval
 
   delegate :step?, :skip?, :leap?, :large_leap?, to: :category
   delegate(
-    :simple_number, :octaves, :number, :simple?, :compound?, :semitones, :simple_semitones, :steps,
+    :simple_number, :octaves, :number, :simple?, :compound?, :semitones, :simple_semitones, :steps, :simple_steps,
     to: :size
   )
   delegate(
@@ -277,7 +303,7 @@ class HeadMusic::FunctionalInterval
     while inverted_low_pitch < higher_pitch
       inverted_low_pitch = HeadMusic::Pitch.fetch_or_create(lower_pitch.spelling, inverted_low_pitch.octave + 1)
     end
-    HeadMusic::FunctionalInterval.new(higher_pitch, inverted_low_pitch)
+    HeadMusic::DiatonicInterval.new(higher_pitch, inverted_low_pitch)
   end
   alias invert inversion
 
@@ -314,8 +340,12 @@ class HeadMusic::FunctionalInterval
     HeadMusic::Pitch.from_number_and_letter(pitch - semitones, pitch.letter_name.steps_down(number - 1))
   end
 
+  # diatonic set theory
+  alias specific_interval simple_semitones
+  alias diatonic_generic_interval simple_steps
+
   def <=>(other)
-    other = self.class.get(other) unless other.is_a?(HeadMusic::FunctionalInterval)
+    other = self.class.get(other) unless other.is_a?(HeadMusic::DiatonicInterval)
     semitones <=> other.semitones
   end
 

data/lib/head_music/harmonic_interval.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# A harmonic interval is the functional interval between two notes sounding together.
+# A harmonic interval is the diatonic interval between two notes sounding together.
 class HeadMusic::HarmonicInterval
   attr_reader :voice1, :voice2, :position
 
@@ -10,8 +10,8 @@ class HeadMusic::HarmonicInterval
     @position = position.is_a?(String) ? HeadMusic::Position.new(voice1.composition, position) : position
   end
 
-  def functional_interval
-    @functional_interval ||= HeadMusic::FunctionalInterval.new(lower_pitch, upper_pitch)
+  def diatonic_interval
+    @diatonic_interval ||= HeadMusic::DiatonicInterval.new(lower_pitch, upper_pitch)
   end
 
   def voices
@@ -53,14 +53,14 @@ class HeadMusic::HarmonicInterval
   end
 
   def to_s
-    "#{functional_interval} at #{position}"
+    "#{diatonic_interval} at #{position}"
   end
 
   def method_missing(method_name, *args, &block)
-    respond_to_missing?(method_name) ? functional_interval.send(method_name, *args, &block) : super
+    respond_to_missing?(method_name) ? diatonic_interval.send(method_name, *args, &block) : super
   end
 
   def respond_to_missing?(method_name, *_args)
-    functional_interval.respond_to?(method_name)
+    diatonic_interval.respond_to?(method_name)
   end
 end

data/lib/head_music/melodic_interval.rb

@@ -9,8 +9,8 @@ class HeadMusic::MelodicInterval
     @second_note = note2
   end
 
-  def functional_interval
-    @functional_interval ||= HeadMusic::FunctionalInterval.new(first_pitch, second_pitch)
+  def diatonic_interval
+    @diatonic_interval ||= HeadMusic::DiatonicInterval.new(first_pitch, second_pitch)
   end
 
   def position_start
@@ -38,7 +38,7 @@ class HeadMusic::MelodicInterval
   end
 
   def to_s
-    [direction, functional_interval].join(' ')
+    [direction, diatonic_interval].join(' ')
   end
 
   def ascending?
@@ -86,14 +86,14 @@ class HeadMusic::MelodicInterval
     combined_pitches = (pitches + other_interval.pitches).uniq
     return false if combined_pitches.length < 3
 
-    HeadMusic::Chord.new(combined_pitches).consonant_triad?
+    HeadMusic::PitchSet.new(combined_pitches).consonant_triad?
   end
 
   def method_missing(method_name, *args, &block)
-    respond_to_missing?(method_name) ? functional_interval.send(method_name, *args, &block) : super
+    respond_to_missing?(method_name) ? diatonic_interval.send(method_name, *args, &block) : super
   end
 
   def respond_to_missing?(method_name, *_args)
-    functional_interval.respond_to?(method_name)
+    diatonic_interval.respond_to?(method_name)
   end
 end

data/lib/head_music/octave.rb

@@ -34,7 +34,7 @@ class HeadMusic::Octave
   delegate :to_i, :to_s, to: :number
 
   def initialize(number)
-    @number ||= number
+    @number = number
   end
 
   def <=>(other)

data/lib/head_music/pitch.rb

@@ -64,7 +64,8 @@ class HeadMusic::Pitch
 
   def self.natural_letter_pitch(number, letter_name)
     natural_letter_pitch = get(HeadMusic::LetterName.get(letter_name).pitch_class)
-    natural_letter_pitch += 12 while (number - natural_letter_pitch.to_i).to_i >= 11
+    natural_letter_pitch += 12 while (number.to_i - natural_letter_pitch.to_i) >= 6
+    natural_letter_pitch -= 12 while (number.to_i - natural_letter_pitch.to_i) <= -6
     get(natural_letter_pitch)
   end
 
@@ -106,7 +107,7 @@ class HeadMusic::Pitch
   end
 
   def +(other)
-    if other.is_a?(HeadMusic::FunctionalInterval)
+    if other.is_a?(HeadMusic::DiatonicInterval)
       # return a pitch
       other.above(self)
     else
@@ -116,12 +117,12 @@ class HeadMusic::Pitch
   end
 
   def -(other)
-    if other.is_a?(HeadMusic::FunctionalInterval)
+    if other.is_a?(HeadMusic::DiatonicInterval)
       # return a pitch
       other.below(self)
     elsif other.is_a?(HeadMusic::Pitch)
       # return an interval
-      HeadMusic::Interval.get(to_i - other.to_i)
+      HeadMusic::ChromaticInterval.get(to_i - other.to_i)
     else
       # assume value represents an interval in semitones and return another pitch
       HeadMusic::Pitch.get(to_i - other.to_i)

data/lib/head_music/pitch_class.rb

@@ -2,6 +2,8 @@
 
 # A pitch class is a set of pitches separated by octaves.
 class HeadMusic::PitchClass
+  include Comparable
+
   attr_reader :number
   attr_reader :spelling
 
@@ -58,10 +60,14 @@ class HeadMusic::PitchClass
   end
   alias enharmonic? ==
 
+  def <=>(other)
+    to_i <=> other.to_i
+  end
+
   def intervals_to(other)
     delta = other.to_i - to_i
     inverse = delta.positive? ? delta - 12 : delta + 12
-    [delta, inverse].sort_by(&:abs).map { |interval| HeadMusic::Interval.get(interval) }
+    [delta, inverse].sort_by(&:abs).map { |interval| HeadMusic::ChromaticInterval.get(interval) }
   end
 
   def smallest_interval_to(other)

data/lib/head_music/pitch_class_set.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# A PitchClassSet represents a pitch-class set or pitch collection.
+# See also: PitchSet, PitchClass
+class HeadMusic::PitchClassSet
+  attr_reader :pitch_classes
+
+  delegate :empty?, to: :pitch_classes
+  alias empty_set? empty?
+
+  def initialize(identifiers)
+    @pitch_classes = identifiers.map { |identifier| HeadMusic::PitchClass.get(identifier) }.uniq.sort
+  end
+
+  def inspect
+    pitch_classes.map(&:to_s).join(' ')
+  end
+
+  def to_s
+    pitch_classes.map(&:to_s).join(' ')
+  end
+
+  def ==(other)
+    pitch_classes == other.pitch_classes
+  end
+
+  def equivalent?(other)
+    pitch_classes.sort == other.pitch_classes.sort
+  end
+
+  def size
+    @size ||= pitch_classes.length
+  end
+
+  def monochord?
+    pitch_classes.length == 1
+  end
+  alias monad? monochord?
+
+  def dichord?
+    pitch_classes.length == 2
+  end
+  alias dyad? dichord?
+
+  def trichord?
+    pitch_classes.length == 3
+  end
+
+  def tetrachord?
+    pitch_classes.length == 4
+  end
+
+  def pentachord?
+    pitch_classes.length == 5
+  end
+
+  def hexachord?
+    pitch_classes.length == 6
+  end
+
+  def heptachord?
+    pitch_classes.length == 7
+  end
+
+  def octachord?
+    pitch_classes.length == 8
+  end
+
+  def nonachord?
+    pitch_classes.length == 9
+  end
+
+  def decachord?
+    pitch_classes.length == 10
+  end
+
+  def undecachord?
+    pitch_classes.length == 11
+  end
+
+  def dodecachord?
+    pitch_classes.length == 12
+  end
+end

data/lib/head_music/pitch_set.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+# A PitchSet is a collection of one or more pitches.
+# See also: PitchClassSet
+class HeadMusic::PitchSet
+  TERTIAN_SONORITIES = {
+    implied_triad: [3],
+    triad: [3, 5],
+    seventh_chord: [3, 5, 7],
+    ninth_chord: [2, 3, 5, 7],
+    eleventh_chord: [2, 3, 4, 5, 7],
+    thirteenth_chord: [2, 3, 4, 5, 6, 7], # a.k.a. diatonic scale
+  }.freeze
+
+  attr_reader :pitches
+
+  delegate :diatonic_intervals, to: :reduction, prefix: true
+  delegate :empty?, :empty_set?, to: :pitch_class_set
+  delegate :monochord?, :monad?, :dichord?, :dyad?, to: :pitch_class_set
+  delegate :trichord?, :tetrachord?, :pentachord?, :hexachord?, to: :pitch_class_set
+  delegate :heptachord?, :octachord?, :nonachord?, :decachord?, :undecachord?, :dodecachord?, to: :pitch_class_set
+  delegate :size, to: :pitch_class_set, prefix: true
+
+  def initialize(pitches)
+    @pitches = pitches.map { |pitch| HeadMusic::Pitch.get(pitch) }.sort.uniq
+  end
+
+  def pitch_classes
+    @pitch_classes ||= reduction_pitches.map(&:pitch_class).uniq
+  end
+
+  def pitch_class_set
+    @pitch_class_set ||= HeadMusic::PitchClassSet.new(pitch_classes)
+  end
+
+  def reduction
+    @reduction ||= HeadMusic::PitchSet.new(reduction_pitches)
+  end
+
+  def diatonic_intervals
+    @diatonic_intervals ||= pitches.each_cons(2).map do |pitch_pair|
+      HeadMusic::DiatonicInterval.new(*pitch_pair)
+    end
+  end
+
+  def diatonic_intervals_above_bass_pitch
+    @diatonic_intervals_above_bass_pitch ||= pitches_above_bass_pitch.map do |pitch|
+      HeadMusic::DiatonicInterval.new(bass_pitch, pitch)
+    end
+  end
+
+  def pitches_above_bass_pitch
+    @pitches_above_bass_pitch ||= pitches.drop(1)
+  end
+
+  def integer_notation
+    @integer_notation ||= begin
+      return [] if pitches.empty?
+      diatonic_intervals_above_bass_pitch.map { |interval| interval.semitones % 12 }.flatten.sort.unshift(0)
+    end
+  end
+
+  def invert
+    inverted_pitch = pitches[0] + HeadMusic::DiatonicInterval.get('perfect octave')
+    new_pitches = pitches.drop(1) + [inverted_pitch]
+    HeadMusic::PitchSet.new(new_pitches)
+  end
+
+  def uninvert
+    inverted_pitch = pitches[-1] - HeadMusic::DiatonicInterval.get('perfect octave')
+    new_pitches = [inverted_pitch] + pitches[0..-2]
+    HeadMusic::PitchSet.new(new_pitches)
+  end
+
+  def bass_pitch
+    @bass_pitch ||= pitches.first
+  end
+
+  def inspect
+    pitches.map(&:to_s).join(' ')
+  end
+
+  def to_s
+    pitches.map(&:to_s).join(' ')
+  end
+
+  def ==(other)
+    pitches.sort == other.pitches.sort
+  end
+
+  def equivalent?(other)
+    pitch_classes.sort == other.pitch_classes.sort
+  end
+
+  def size
+    pitches.length
+  end
+
+  def triad?
+    trichord? && tertian?
+  end
+
+  def consonant_triad?
+    major_triad? || minor_triad?
+  end
+
+  def major_triad?
+    [%w[M3 m3], %w[m3 P4], %w[P4 M3]].include? reduction_diatonic_intervals.map(&:shorthand)
+  end
+
+  def minor_triad?
+    [%w[m3 M3], %w[M3 P4], %w[P4 m3]].include? reduction_diatonic_intervals.map(&:shorthand)
+  end
+
+  def diminished_triad?
+    [%w[m3 m3], %w[m3 A4], %w[A4 m3]].include? reduction_diatonic_intervals.map(&:shorthand)
+  end
+
+  def augmented_triad?
+    [%w[M3 M3], %w[M3 d4], %w[d4 M3]].include? reduction_diatonic_intervals.map(&:shorthand)
+  end
+
+  def root_position_triad?
+    trichord? && reduction_diatonic_intervals.all?(&:third?)
+  end
+
+  def first_inversion_triad?
+    trichord? && reduction.uninvert.diatonic_intervals.all?(&:third?)
+  end
+
+  def second_inversion_triad?
+    trichord? && reduction.invert.diatonic_intervals.all?(&:third?)
+  end
+
+  def seventh_chord?
+    tetrachord? && tertian?
+  end
+
+  def root_position_seventh_chord?
+    tetrachord? && reduction_diatonic_intervals.all?(&:third?)
+  end
+
+  def first_inversion_seventh_chord?
+    tetrachord? && reduction.uninvert.diatonic_intervals.all?(&:third?)
+  end
+
+  def second_inversion_seventh_chord?
+    tetrachord? && reduction.uninvert.uninvert.diatonic_intervals.all?(&:third?)
+  end
+
+  def third_inversion_seventh_chord?
+    tetrachord? && reduction.invert.diatonic_intervals.all?(&:third?)
+  end
+
+  def ninth_chord?
+    pentachord? && tertian?
+  end
+
+  def eleventh_chord?
+    hexachord? && tertian?
+  end
+
+  def thirteenth_chord?
+    heptachord? && tertian?
+  end
+
+  def tertian?
+    return false unless diatonic_intervals.any?
+
+    inversion = reduction
+    pitches.length.times do
+      return true if TERTIAN_SONORITIES.value?(inversion.scale_degrees_above_bass_pitch)
+      inversion = inversion.invert
+    end
+    false
+  end
+
+  def scale_degrees
+    @scale_degrees ||= pitches.empty? ? [] : scale_degrees_above_bass_pitch.unshift(1)
+  end
+
+  def scale_degrees_above_bass_pitch
+    @scale_degrees_above_bass_pitch ||= diatonic_intervals_above_bass_pitch.map(&:simple_number).sort - [8]
+  end
+
+  private
+
+  def reduction_pitches
+    pitches.map do |pitch|
+      pitch = HeadMusic::Pitch.fetch_or_create(pitch.spelling, pitch.octave - 1) while pitch > bass_pitch + 12
+      pitch
+    end.sort
+  end
+end

data/lib/head_music/reference_pitch.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# A reference pitch has a pitch and a frequency
+# With no arguments, it assumes that A4 = 440.0 Hz
+class HeadMusic::ReferencePitch
+  include HeadMusic::NamedRudiment
+
+  DEFAULT_PITCH_NAME = 'A4'
+  DEFAULT_FREQUENCY = 440.0
+
+  NAMED_REFERENCE_PITCHES = [
+    { name: 'Baroque', pitch: 'A4', frequency: 415.0 },
+    { name: 'Classical', pitch: 'A4', frequency: 430.0 },
+    { name: 'Scientific', pitch: 'C4', frequency: 256.0 },
+    { name: 'Verdi', pitch: 'A4', frequency: 432.0 }, # Pythagorean tuning
+    { name: 'French', pitch: 'A4', frequency: 435.0 },
+    { name: 'New Philharmonic', pitch: 'A4', frequency: 439.0 },
+    { name: 'A440', pitch: 'A4', frequency: 440.0 },
+    { name: 'Sydney Symphony Orchestra', pitch: 'A4', frequency: 441.0 },
+    { name: 'New York Philharmonic', pitch: 'A4', frequency: 442.0 },
+    { name: 'Berlin Philharmonic', pitch: 'A4', frequency: 443.0 },
+    { name: 'Boston Symphony Orchestra', pitch: 'A4', frequency: 444.0 },
+    { name: 'Old Philharmonic', pitch: 'A4', frequency: 452.4 },
+    { name: 'Chorton', pitch: 'A4', frequency: 466.0 },
+  ].freeze
+
+  ALIASES = {
+    kammerton: :baroque,
+    chamber: :baroque,
+    haydn: :classical,
+    mozart: :classical,
+    philosophic: :scientific,
+    sauveur: :scientific,
+    schiller: :scientific,
+    continental: :french,
+    international: :french,
+    low: :new_philharmonic,
+    concert: :a440,
+    stuttgart: :a440,
+    scheibler: :a440,
+    iso_16: :a440,
+    high: :old_philharmonic,
+    choir: :chorton,
+  }.freeze
+
+  NAMED_REFERENCE_PITCH_NAMES = NAMED_REFERENCE_PITCHES.map { |pitch_data| pitch_data[:name] }
+
+  attr_reader :pitch, :frequency
+
+  def self.get(name)
+    return name if name.is_a?(self)
+    get_by_name(name)
+  end
+
+  def initialize(name = 'A440')
+    @name = name.to_s
+    reference_pitch_data = NAMED_REFERENCE_PITCHES.detect do |candidate|
+      candidate_name_key = HeadMusic::Utilities::HashKey.for(candidate[:name])
+      [candidate_name_key, candidate_name_key.to_s.delete('_').to_sym].include?(normalized_name)
+    end || {}
+    @pitch = HeadMusic::Pitch.get(reference_pitch_data.fetch(:pitch, DEFAULT_PITCH_NAME))
+    @frequency = reference_pitch_data.fetch(:frequency, DEFAULT_FREQUENCY)
+  end
+
+  def description
+    [
+      pitch.letter_name,
+      format(
+        '%<with_digits>g',
+        with_digits: format('%.2f', frequency)
+      ),
+    ].join('=')
+  end
+
+  def to_s
+    description
+  end
+
+  private
+
+  def normalized_name
+    @normalized_name ||= begin
+      key = HeadMusic::Utilities::HashKey.for(name.to_s.gsub(/\W?(pitch|tuning|tone)/, ''))
+      ALIASES[key] || key
+    end
+  end
+end

data/lib/head_music/rhythmic_unit.rb

@@ -27,7 +27,7 @@ class HeadMusic::RhythmicUnit
   end
 
   def initialize(canonical_name)
-    @name ||= canonical_name
+    @name = canonical_name
     @numerator = 2**numerator_exponent
     @denominator = 2**denominator_exponent
   end
@@ -80,10 +80,26 @@ class HeadMusic::RhythmicUnit
   end
 
   def numerator_exponent
-    MULTIPLES.index(name) || BRITISH_MULTIPLE_NAMES.index(name) || 0
+    multiples_keys.index(name.gsub(/\W+/, '_')) || british_multiples_keys.index(name.gsub(/\W+/, '_')) || 0
+  end
+
+  def multiples_keys
+    MULTIPLES.map { |multiple| multiple.gsub(/\W+/, '_') }
+  end
+
+  def british_multiples_keys
+    BRITISH_MULTIPLE_NAMES.map { |multiple| multiple.gsub(/\W+/, '_') }
   end
 
   def denominator_exponent
-    FRACTIONS.index(name) || BRITISH_DIVISION_NAMES.index(name) || 0
+    fractions_keys.index(name.gsub(/\W+/, '_')) || british_fractions_keys.index(name.gsub(/\W+/, '_')) || 0
+  end
+
+  def fractions_keys
+    FRACTIONS.map { |fraction| fraction.gsub(/\W+/, '_') }
+  end
+
+  def british_fractions_keys
+    BRITISH_DIVISION_NAMES.map { |fraction| fraction.gsub(/\W+/, '_') }
   end
 end

data/lib/head_music/sonority.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# A Sonority describes a set of pitch class intervalic relationships.
+# For example, a minor triad, or a major-minor seventh chord.
+# The Sonority class is a factory for returning one of its subclasses.
+class HeadMusic::Sonority
+  SONORITIES = {
+    major_triad: %w[M3 P5],
+    minor_triad: %w[m3 P5],
+    diminished_triad: %w[m3 d5],
+    augmented_triad: %w[M3 A5],
+    major_minor_seventh_chord: %w[M3 P5 m7],
+    major_major_seventh_chord: %w[M3 P5 M7],
+    minor_minor_seventh_chord: %w[m3 P5 m7],
+    minor_major_seventh_chord: %w[m3 P5 M7],
+    half_diminished_seventh_chord: %w[m3 d5 m7],
+    diminished_seventh_chord: %w[m3 d5 d7],
+    dominant_ninth_chord: %w[M2 M3 P5 m7],
+    dominant_minor_ninth_chord: %w[m2 M3 P5 m7],
+    minor_ninth_chord: %w[M2 m3 P5 m7],
+    major_ninth_chord: %w[M2 M3 P5 M7],
+    six_nine_chord: %w[M2 M3 P5 M6],
+    minor_six_nine_chord: %w[M2 m3 P5 M6],
+    suspended_four_chord: %w[P4 P5],
+    suspended_two_chord: %w[M2 P5],
+    quartal_chord: %w[P4 m7],
+  }.freeze
+
+  attr_reader :pitch_set
+
+  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
+
+  def initialize(pitch_set)
+    @pitch_set = pitch_set
+    identifier
+  end
+
+  def identifier
+    return @identifier if defined?(@identifier)
+
+    @identifier = SONORITIES.keys.detect do |key|
+      inversions.map do |inversion|
+        inversion.diatonic_intervals_above_bass_pitch.map(&:shorthand)
+      end.include?(SONORITIES[key])
+    end
+  end
+
+  def inversion
+    @inversion ||= inversions.index do |inversion|
+      SONORITIES[identifier] == inversion.diatonic_intervals_above_bass_pitch.map(&:shorthand)
+    end
+  end
+
+  def inversions
+    @inversions ||= begin
+      inversion = reduction
+      inversions = []
+      inversion.pitches.length.times do |_i|
+        inversions << inversion
+        inversion = inversion.uninvert
+      end
+      inversions
+    end
+  end
+
+  def root_position
+    @root_position ||= inversions[inversion]
+  end
+
+  def consonant?
+    @consonant ||=
+      pitch_set.reduction_diatonic_intervals.all?(&:consonant?) &&
+      root_position.diatonic_intervals_above_bass_pitch.all?(&:consonant?)
+  end
+
+  def triad?
+    @triad ||= trichord? && tertian?
+  end
+
+  def seventh_chord?
+    @seventh_chord ||= tetrachord? && tertian?
+  end
+
+  def tertian?
+    @tertian ||= inversions.detect do |inversion|
+      inversion.diatonic_intervals.count(&:third?).to_f / inversion.diatonic_intervals.length > 0.5 ||
+        (scale_degrees_above_bass_pitch && [3, 5, 7]).length == 3
+    end
+  end
+
+  def secundal?
+    @secundal ||= inversions.detect do |inversion|
+      inversion.diatonic_intervals.count(&:second?).to_f / inversion.diatonic_intervals.length > 0.5
+    end
+  end
+
+  def quartal?
+    @quartal ||= inversions.detect do |inversion|
+      inversion.diatonic_intervals.count do |interval|
+        interval.fourth? || interval.fifth?
+      end.to_f / inversion.diatonic_intervals.length > 0.5
+    end
+  end
+  alias quintal? quartal?
+
+  def diatonic_intervals_above_bass_pitch
+    return nil unless identifier
+
+    @diatonic_intervals_above_bass_pitch ||=
+      SONORITIES[identifier].map { |shorthand| HeadMusic::DiatonicInterval.get(shorthand) }
+  end
+
+  def ==(other)
+    other = HeadMusic::PitchSet.new(other) if other.is_a?(Array)
+    other = self.class.new(other) if other.is_a?(HeadMusic::PitchSet)
+    identifier == other.identifier
+  end
+end

data/lib/head_music/style/annotation.rb

@@ -48,10 +48,6 @@ class HeadMusic::Style::Annotation
     [marks].flatten.compact.map(&:end_position).max
   end
 
-  def marks
-    raise NotImplementedError
-  end
-
   def message
     self.class::MESSAGE
   end
@@ -86,10 +82,10 @@ class HeadMusic::Style::Annotation
     @lower_voices ||= unsorted_lower_voices.sort_by(&:lowest_pitch).reverse
   end
 
-  def functional_interval_from_tonic(note)
+  def diatonic_interval_from_tonic(note)
     tonic_to_use = tonic_pitch
-    tonic_to_use -= HeadMusic::Interval.get(:perfect_octave) while tonic_to_use > note.pitch
-    HeadMusic::FunctionalInterval.new(tonic_to_use, note.pitch)
+    tonic_to_use -= HeadMusic::ChromaticInterval.get(:perfect_octave) while tonic_to_use > note.pitch
+    HeadMusic::DiatonicInterval.new(tonic_to_use, note.pitch)
   end
 
   def bass_voice?

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

@@ -25,6 +25,6 @@ class HeadMusic::Style::Guidelines::ApproachPerfectionContrarily < HeadMusic::St
     end
   end
 
-  # Side effect is that you can't enter a perfect consonance by skip,
+  # Side effect is that you can't enter a perfect consonance by skip in similar or parallel motion,
   # which is a rule.
 end

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

@@ -29,21 +29,21 @@ class HeadMusic::Style::Guidelines::ConsonantClimax < HeadMusic::Style::Annotati
   end
 
   def highest_pitch_consonant_with_tonic?
-    functional_interval_to_highest_pitch.consonance?(:melodic)
+    diatonic_interval_to_highest_pitch.consonance?(:melodic)
   end
 
   def lowest_pitch_consonant_with_tonic?
-    functional_interval_to_lowest_pitch.consonance?(:melodic)
+    diatonic_interval_to_lowest_pitch.consonance?(:melodic)
   end
 
-  def functional_interval_to_highest_pitch
-    @functional_interval_to_highest_pitch ||=
-      HeadMusic::FunctionalInterval.new(tonic_pitch, highest_pitch)
+  def diatonic_interval_to_highest_pitch
+    @diatonic_interval_to_highest_pitch ||=
+      HeadMusic::DiatonicInterval.new(tonic_pitch, highest_pitch)
   end
 
-  def functional_interval_to_lowest_pitch
-    @functional_interval_to_lowest_pitch ||=
-      HeadMusic::FunctionalInterval.new(tonic_pitch, lowest_pitch)
+  def diatonic_interval_to_lowest_pitch
+    @diatonic_interval_to_lowest_pitch ||=
+      HeadMusic::DiatonicInterval.new(tonic_pitch, lowest_pitch)
   end
 
   def highest_pitch_appears_once?

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

@@ -14,6 +14,6 @@ class HeadMusic::Style::Guidelines::EndOnPerfectConsonance < HeadMusic::Style::A
   private
 
   def ends_on_perfect_consonance?
-    functional_interval_from_tonic(last_note).perfect_consonance?(:two_part_harmony)
+    diatonic_interval_from_tonic(last_note).perfect_consonance?(:two_part_harmony)
   end
 end

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

@@ -16,6 +16,6 @@ class HeadMusic::Style::Guidelines::StartOnPerfectConsonance < HeadMusic::Style:
   private
 
   def starts_on_perfect_consonance?
-    functional_interval_from_tonic(first_note).perfect_consonance?(:two_part_harmony)
+    diatonic_interval_from_tonic(first_note).perfect_consonance?(:two_part_harmony)
   end
 end

data/lib/head_music/tuning.rb

@@ -3,19 +3,17 @@
 # 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::Tuning
-  REFERENCE_PITCH_NAME = 'A4'
-  REFERENCE_FREQUENCY = 440.0
+  attr_accessor :reference_pitch
 
-  attr_reader :reference_pitch, :reference_frequency
+  delegate :pitch, :frequency, to: :reference_pitch, prefix: true
 
-  def initialize(reference_pitch: nil, reference_frequency: nil)
-    @reference_pitch = reference_pitch || HeadMusic::Pitch.get(REFERENCE_PITCH_NAME)
-    @reference_frequency = reference_frequency || REFERENCE_FREQUENCY
+  def initialize(reference_pitch: :a440)
+    @reference_pitch = HeadMusic::ReferencePitch.get(reference_pitch)
   end
 
   def frequency_for(pitch)
     pitch = HeadMusic::Pitch.get(pitch) unless pitch.is_a?(HeadMusic::Pitch)
-    reference_frequency * (2**(1.0 / 12))**(pitch - reference_pitch).semitones
+    reference_pitch_frequency * (2**(1.0 / 12))**(pitch - reference_pitch.pitch).semitones
   end
 end
 

data/lib/head_music/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HeadMusic
-  VERSION = '0.22.0'
+  VERSION = '0.23.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-13 00:00:00.000000000 Z
+date: 2019-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -120,7 +120,7 @@ files:
 - bin/setup
 - head_music.gemspec
 - lib/head_music.rb
-- lib/head_music/chord.rb
+- lib/head_music/chromatic_interval.rb
 - lib/head_music/circle.rb
 - lib/head_music/clef.rb
 - lib/head_music/consonance.rb
@@ -131,11 +131,10 @@ files:
 - lib/head_music/content/position.rb
 - lib/head_music/content/rhythmic_value.rb
 - lib/head_music/content/voice.rb
-- lib/head_music/functional_interval.rb
+- lib/head_music/diatonic_interval.rb
 - lib/head_music/grand_staff.rb
 - lib/head_music/harmonic_interval.rb
 - lib/head_music/instrument.rb
-- lib/head_music/interval.rb
 - lib/head_music/key_signature.rb
 - lib/head_music/letter_name.rb
 - lib/head_music/melodic_interval.rb
@@ -147,13 +146,17 @@ files:
 - lib/head_music/pitch/enharmonic_equivalence.rb
 - lib/head_music/pitch/octave_equivalence.rb
 - lib/head_music/pitch_class.rb
+- lib/head_music/pitch_class_set.rb
+- lib/head_music/pitch_set.rb
 - lib/head_music/quality.rb
+- lib/head_music/reference_pitch.rb
 - lib/head_music/rhythm.rb
 - lib/head_music/rhythmic_unit.rb
 - lib/head_music/scale.rb
 - lib/head_music/scale_degree.rb
 - lib/head_music/scale_type.rb
 - lib/head_music/sign.rb
+- lib/head_music/sonority.rb
 - lib/head_music/spelling.rb
 - lib/head_music/staff.rb
 - lib/head_music/style/analysis.rb

data/lib/head_music/chord.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-# A Chord is a collection of three or more pitches
-class HeadMusic::Chord
-  attr_reader :pitches
-
-  def initialize(pitches)
-    raise ArgumentError if pitches.length < 3
-
-    @pitches = pitches.map { |pitch| HeadMusic::Pitch.get(pitch) }.sort
-  end
-
-  def consonant_triad?
-    reduction.root_triad? || reduction.first_inversion_triad? || reduction.second_inversion_triad?
-  end
-
-  def root_triad?
-    return false unless triad?
-
-    intervals.map(&:shorthand).sort == %w[M3 m3]
-  end
-
-  # TODO: look up definition of first and second inversion triads. Can they be spread?
-  def first_inversion_triad?
-    return false unless triad?
-
-    invert.invert.intervals.map(&:shorthand).sort == %w[M3 m3]
-  end
-
-  def second_inversion_triad?
-    return false unless triad?
-
-    invert.intervals.map(&:shorthand).sort == %w[M3 m3]
-  end
-
-  def reduction
-    @reduction ||= HeadMusic::Chord.new(reduction_pitches)
-  end
-
-  def triad?
-    pitches.length == 3
-  end
-
-  def intervals
-    pitches.each_cons(2).map do |pitch_pair|
-      HeadMusic::FunctionalInterval.new(*pitch_pair)
-    end
-  end
-
-  def invert
-    inverted_pitch = pitches[0] + HeadMusic::Interval.get(12)
-    new_pitches = pitches.drop(1) + [inverted_pitch]
-    HeadMusic::Chord.new(new_pitches)
-  end
-
-  def bass_pitch
-    @bass_pitch ||= pitches.first
-  end
-
-  def inspect
-    pitches.map(&:to_s).join(' ')
-  end
-
-  def to_s
-    pitches.map(&:to_s).join(' ')
-  end
-
-  def ==(other)
-    pitches & other.pitches == pitches
-  end
-
-  private
-
-  def reduction_pitches
-    pitches.map do |pitch|
-      pitch = HeadMusic::Pitch.fetch_or_create(pitch.spelling, pitch.octave - 1) while pitch > bass_pitch + 12
-      pitch
-    end.sort
-  end
-end