head_music 0.11.9 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a0baef52f11f8aab0c4becbe31e70928b358499
-  data.tar.gz: 47ae1ef06c1e25a2abd0559eb40a20494c47eed3
+  metadata.gz: f1c8d179b57fdcf25212aa045104c235981b7618
+  data.tar.gz: 324f02d328e7f94a35bcce3edf754d186f6f127b
 SHA512:
-  metadata.gz: 07e0d608df0d6e5901e652c8796b84ef99c2987c94a346347efff6c73d0b159352d0813eaa2a932530fe7f5e1613548c96ca9c2dbcc2b486ef4978d4e6509235
-  data.tar.gz: 1dd90a0197c26138b56b109de9dae548c5b9d4b6f4f382b13da80b2fa1093d006c197e26523ff4f2bacb5863bee878d36037049857e8c2655bb3fd61125ec7ae
+  metadata.gz: 6d59e0eee2a58b5126bed466801d27bb2f64b93b736057a2802b9b17f133e67b9b60fdbc19aefbd974e5ea6872a9a50095f760b4677e5f31c5631734c47dd977
+  data.tar.gz: 92548ec40646df28b54230aba80dba41bd9470024397b627658e8d27c2026ea6909992effc98d8959fd49e715f1b1750c532e8950edc06b363f4d692f1cb2339

data/README.md

@@ -24,7 +24,7 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+HeadMusic can be used as a foundation to build larger applications that notate, analyze, play, or generate music in the language of music theory.
 
 ## Development
 

data/lib/head_music/bar.rb

@@ -1,14 +1,16 @@
+# Representation of a bar in a composition
+# Encapsulates meter and key signature changes
 class HeadMusic::Bar
   attr_reader :composition
+  attr_accessor :key_signature, :meter
 
-  delegate :key_signature, :meter, to: :composition
-
-  def initialize(composition)
+  def initialize(composition, key_signature: nil, meter: nil)
     @composition = composition
+    @key_signature = HeadMusic::KeySignature.get(key_signature) if key_signature
+    @meter = HeadMusic::Meter.get(meter) if meter
   end
 
-  # TODO: encapsulate key changes and meter changes
-  # Assume the key and meter of the previous bar
-  # all the way back to the first bar,
-  # which defaults to the key and meter of the composition
+  def to_s
+    ['Bar', key_signature, meter].reject(&:nil?).join(' ')
+  end
 end

data/lib/head_music/clef.rb

@@ -1,4 +1,6 @@
 class HeadMusic::Clef
+  include HeadMusic::NamedRudiment
+
   CLEFS = [
     { pitch: 'G4', line: 2, names: ['treble', 'G-clef'], modern: true },
     { pitch: 'G4', line: 1, names: ['French', 'French violin'] },
@@ -18,14 +20,10 @@ class HeadMusic::Clef
   ]
 
   def self.get(name)
-    name = name.to_s
-    @clefs ||= {}
-    key = HeadMusic::Utilities::HashKey.for(name)
-    @clefs[key] ||= new(name)
+    get_by_name(name)
   end
 
-  attr_reader :name, :pitch, :line
-  delegate :to_s, to: :name
+  attr_reader :pitch, :line
 
   def initialize(name)
     @name = name.to_s

data/lib/head_music/composition.rb

@@ -1,25 +1,48 @@
 class HeadMusic::Composition
-  attr_reader :name, :key_signature, :meter, :bars, :voices
+  attr_reader :name, :key_signature, :meter, :voices
 
   def initialize(name: nil, key_signature: nil, meter: nil)
     ensure_attributes(name, key_signature, meter)
     @voices = []
   end
 
-  def add_bar
-    add_bars(1)
+  def add_voice(role: nil)
+    @voices << HeadMusic::Voice.new(composition: self, role: role)
+    @voices.last
+  end
+
+  def meter_at(bar_number)
+    meter_change = last_meter_change(bar_number)
+    meter_change ? meter_change.meter : meter
   end
 
-  def add_bars(number)
+  def key_signature_at(bar_number)
+    key_signature_change = last_key_signature_change(bar_number)
+    key_signature_change ? key_signature_change.key_signature : key_signature
+  end
+
+  def bars(last = latest_bar_number)
     @bars ||= []
-    number.times do
-      @bars << HeadMusic::Bar.new(self)
+    (earliest_bar_number..last).each do |bar_number|
+      @bars[bar_number] ||= Bar.new(self)
     end
+    @bars[earliest_bar_number..last]
   end
 
-  def add_voice(role: nil)
-    @voices << HeadMusic::Voice.new(composition: self, role: role)
-    @voices.last
+  def change_key_signature(bar_number, key_signature)
+    bars(bar_number).last.key_signature = key_signature
+  end
+
+  def change_meter(bar_number, meter)
+    bars(bar_number).last.meter = meter
+  end
+
+  def earliest_bar_number
+    [voices.map(&:earliest_bar_number), 1].flatten.min
+  end
+
+  def latest_bar_number
+    [voices.map(&:earliest_bar_number), 1].flatten.max
   end
 
   private
@@ -31,4 +54,12 @@ class HeadMusic::Composition
     @meter = HeadMusic::Meter.get(meter) if meter
     @meter ||= HeadMusic::Meter.default
   end
+
+  def last_meter_change(bar_number)
+    bars(bar_number)[earliest_bar_number..bar_number].reverse.detect(&:meter)
+  end
+
+  def last_key_signature_change(bar_number)
+    bars(bar_number)[earliest_bar_number..bar_number].reverse.detect(&:key_signature)
+  end
 end

data/lib/head_music/functional_interval.rb

@@ -1,4 +1,6 @@
 class HeadMusic::FunctionalInterval
+  include Comparable
+
   NUMBER_NAMES = %w[unison second third fourth fifth sixth seventh octave ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth]
   NAME_SUFFIXES = Hash.new('th').merge({ 1 => 'st', 2 => 'nd', 3 => 'rd' })
 
@@ -22,7 +24,7 @@ class HeadMusic::FunctionalInterval
     seventeenth: { major: 28 }
   }
 
-  attr_reader :lower_pitch, :higher_pitch, :direction
+  attr_reader :lower_pitch, :higher_pitch
 
   delegate :to_s, to: :name
   delegate :perfect?, :major?, :minor?, :diminished?, :augmented?, :doubly_diminished?, :doubly_augmented?, to: :quality
@@ -62,33 +64,17 @@ class HeadMusic::FunctionalInterval
   def initialize(pitch1, pitch2)
     pitch1 = HeadMusic::Pitch.get(pitch1)
     pitch2 = HeadMusic::Pitch.get(pitch2)
-    set_direction(pitch1, pitch2)
     @lower_pitch, @higher_pitch = [pitch1, pitch2].sort
   end
 
-  def set_direction(pitch1, pitch2)
-    @direction =
-      if pitch1 == pitch2
-        :none
-      elsif pitch1 < pitch2
-        :ascending
-      else
-        :descending
-      end
-  end
-
-  def descending?
-    direction == :descending
-  end
-
-  def ascending?
-    direction == :ascending
-  end
-
   def number
     simple_number + octaves * 7
   end
 
+  def steps
+    number - 1
+  end
+
   def simple_number
     @simple_number ||= @lower_pitch.letter_name.steps_to(@higher_pitch.letter_name) + 1
   end
@@ -161,21 +147,9 @@ class HeadMusic::FunctionalInterval
   end
 
   def consonance(style = :standard_practice)
-    if perfect?
-      if fourth? && style == :two_part_harmony
-        HeadMusic::Consonance.get(:dissonant)
-      else
-        HeadMusic::Consonance.get(:perfect)
-      end
-    elsif major? || minor?
-      if third? || sixth?
-        HeadMusic::Consonance.get(:imperfect)
-      else
-        HeadMusic::Consonance.get(:dissonant)
-      end
-    else
+    consonance_for_perfect(style) ||
+      consonance_for_major_and_minor ||
       HeadMusic::Consonance.get(:dissonant)
-    end
   end
 
   def consonance?(style = :standard_practice)
@@ -199,19 +173,39 @@ class HeadMusic::FunctionalInterval
   end
 
   def skip?
-    number == 3
+    number >= 3
   end
 
   def leap?
+    number >= 3
+  end
+
+  def large_leap?
     number > 3
   end
-  alias_method :large_leap?, :leap?
 
-  def ==(other)
-    self.to_s.gsub(/\W/, '_') == other.to_s.gsub(/\W/, '_')
+  def <=>(other)
+    if !other.is_a?(FunctionalInterval)
+      other = self.class.get(other)
+    end
+    self.semitones <=> other.semitones
   end
 
   NUMBER_NAMES.each do |method_name|
-    define_method(:"#{method_name}?") { number_name == method_name || simple_number_name == method_name }
+    define_method(:"#{method_name}?") { number_name == method_name }
+  end
+
+  private
+
+  def consonance_for_perfect(style = :standard_practice)
+    HeadMusic::Consonance.get(dissonant_fourth?(style) ? :dissonant : :perfect) if perfect?
+  end
+
+  def consonance_for_major_and_minor
+    HeadMusic::Consonance.get((third? || sixth?) ? :imperfect : :dissonant) if (major? || minor?)
+  end
+
+  def dissonant_fourth?(style = :standard_practice)
+    fourth? && style == :two_part_harmony
   end
 end

data/lib/head_music/harmonic_interval.rb

@@ -0,0 +1,49 @@
+class HeadMusic::HarmonicInterval
+  attr_reader :voice1, :voice2, :position
+
+  def initialize(voice1, voice2, position)
+    @voice1 = voice1
+    @voice2 = voice2
+    @position = position.is_a?(String) ? Position.new(voice1.composition, position) : position
+  end
+
+  def functional_interval
+    @functional_interval ||= HeadMusic::FunctionalInterval.new(lower_pitch, upper_pitch)
+  end
+
+  def voices
+    [voice1, voice2].reject(&:nil?)
+  end
+
+  def notes
+    @notes ||= voices.map { |voice| voice.note_at(position) }.reject(&:nil?).sort_by(&:pitch)
+  end
+
+  def lower_note
+    notes.first
+  end
+
+  def upper_note
+    notes.last
+  end
+
+  def pitches
+    @pitches ||= notes.map(&:pitch).sort_by(&:to_i)
+  end
+
+  def lower_pitch
+    pitches.first
+  end
+
+  def upper_pitch
+    pitches.last
+  end
+
+  def to_s
+    "#{functional_interval} at #{position}"
+  end
+
+  def method_missing(method_name, *args, &block)
+    functional_interval.send(method_name, *args, &block)
+  end
+end

data/lib/head_music/instrument.rb

@@ -1,4 +1,6 @@
 class HeadMusic::Instrument
+  include HeadMusic::NamedRudiment
+
   INSTRUMENTS = {
     violin: {
       name: "violin",
@@ -13,14 +15,9 @@ class HeadMusic::Instrument
   }
 
   def self.get(name)
-    @instruments ||= {}
-    key = HeadMusic::Utilities::HashKey.for(name)
-    @instruments[key] ||= new(name.to_s)
+    get_by_name(name)
   end
 
-  attr_reader :name
-  delegate :to_s, to: :name
-
   def initialize(name)
     @name = name.to_s
   end
@@ -29,10 +26,6 @@ class HeadMusic::Instrument
     @data ||= INSTRUMENTS[hash_key]
   end
 
-  def hash_key
-    HeadMusic::Utilities::HashKey.for(name)
-  end
-
   def family
     data[:family]
   end

data/lib/head_music/melodic_interval.rb

@@ -24,13 +24,48 @@ class HeadMusic::MelodicInterval
   end
 
   def pitches
-    notes.map(&:pitch)
+    [first_pitch, second_pitch]
+  end
+
+  def first_pitch
+    @first_pitch ||= first_note.pitch
+  end
+
+  def second_pitch
+    @second_pitch ||= second_note.pitch
   end
 
   def to_s
     [direction, functional_interval].join(' ')
   end
 
+  def ascending?
+    direction == :ascending
+  end
+
+  def descending?
+    direction == :descending
+  end
+
+  def moving?
+    ascending? || descending?
+  end
+
+  def repetition?
+    !moving?
+  end
+
+  def direction
+    @direction ||=
+      if first_pitch < second_pitch
+        :ascending
+      elsif first_pitch > second_pitch
+        :descending
+      else
+        :none
+      end
+  end
+
   def method_missing(method_name, *args, &block)
     functional_interval.send(method_name, *args, &block)
   end

data/lib/head_music/meter.rb

@@ -59,9 +59,9 @@ class HeadMusic::Meter
   end
 
   def beat_strength(count, tick: 0)
-    return 100 if count == 1 && tick == 0
-    return 80 if strong_counts.include?(count) && tick == 0
-    return 60 if tick == 0
+    return 100 if downbeat?(count, tick)
+    return 80 if strong_beat?(count, tick)
+    return 60 if beat?(tick)
     return 40 if strong_ticks.include?(tick)
     20
   end
@@ -70,13 +70,6 @@ class HeadMusic::Meter
     @ticks_per_count ||= count_unit.ticks
   end
 
-  def strong_ticks
-    @strong_ticks ||=
-      [2,3,4].map do |sixths|
-        ticks_per_count * (sixths / 6.0)
-      end
-  end
-
   def count_unit
     HeadMusic::RhythmicUnit.for_denominator_value(bottom_number)
   end
@@ -102,14 +95,37 @@ class HeadMusic::Meter
   def strong_counts
     @strong_counts ||= begin
       (1..counts_per_bar).select do |count|
-        count == 1 ||
-        count == counts_per_bar / 2.0 + 1 ||
-        (
-          counts_per_bar % 3 == 0 &&
-          counts_per_bar > 6 &&
-          count % 3 == 1
-        )
+        downbeat?(count) || strong_beat_in_duple?(count) || strong_beat_in_triple?(count)
       end
     end
   end
+
+  def strong_ticks
+    @strong_ticks ||=
+      [2,3,4].map do |sixths|
+        ticks_per_count * (sixths / 6.0)
+      end
+  end
+
+  private
+
+  def downbeat?(count, tick = 0)
+    beat?(tick) && count == 1
+  end
+
+  def strong_beat?(count, tick = 0)
+    beat?(tick) && (strong_beat_in_duple?(count, tick) || strong_beat_in_triple?(count, tick))
+  end
+
+  def strong_beat_in_duple?(count, tick = 0)
+    beat?(tick) && (count == counts_per_bar / 2.0 + 1)
+  end
+
+  def strong_beat_in_triple?(count, tick = 0)
+    beat?(tick) && counts_per_bar % 3 == 0 && counts_per_bar > 6 && count % 3 == 1
+  end
+
+  def beat?(tick)
+    tick == 0
+  end
 end

data/lib/head_music/motion.rb

@@ -0,0 +1,70 @@
+class HeadMusic::Motion
+  attr_reader :first_harmonic_interval, :second_harmonic_interval
+
+  def initialize(first_harmonic_interval, second_harmonic_interval)
+    @first_harmonic_interval = first_harmonic_interval
+    @second_harmonic_interval = second_harmonic_interval
+  end
+
+  def repetition?
+    upper_melodic_interval.repetition? && lower_melodic_interval.repetition?
+  end
+
+  def oblique?
+    upper_melodic_interval.repetition? && lower_melodic_interval.moving? ||
+    lower_melodic_interval.repetition? && upper_melodic_interval.moving?
+  end
+
+  def direct?
+    parallel? || similar?
+  end
+
+  def parallel?
+    upper_melodic_interval.moving? &&
+    upper_melodic_interval.direction == lower_melodic_interval.direction &&
+    upper_melodic_interval.steps == lower_melodic_interval.steps
+  end
+
+  def similar?
+    upper_melodic_interval.direction == lower_melodic_interval.direction &&
+    upper_melodic_interval.steps != lower_melodic_interval.steps
+  end
+
+  def contrary?
+    upper_melodic_interval.moving? &&
+    lower_melodic_interval.moving? &&
+    upper_melodic_interval.direction != lower_melodic_interval.direction
+  end
+
+  def notes
+    upper_notes + lower_notes
+  end
+
+  def contrapuntal_motion
+    [:parallel, :similar, :oblique, :contrary, :repetition].detect do |motion_type|
+      send("#{motion_type}?")
+    end
+  end
+
+  def to_s
+    "#{contrapuntal_motion} motion from #{first_harmonic_interval} to #{second_harmonic_interval}"
+  end
+
+  private
+
+  def upper_melodic_interval
+    HeadMusic::MelodicInterval.new(upper_notes.first.voice, upper_notes.first, upper_notes.last)
+  end
+
+  def lower_melodic_interval
+    HeadMusic::MelodicInterval.new(lower_notes.first.voice, lower_notes.first, lower_notes.last)
+  end
+
+  def upper_notes
+    [first_harmonic_interval, second_harmonic_interval].map(&:upper_note)
+  end
+
+  def lower_notes
+    [first_harmonic_interval, second_harmonic_interval].map(&:lower_note)
+  end
+end

data/lib/head_music/named_rudiment.rb

@@ -0,0 +1,27 @@
+module HeadMusic
+  module NamedRudiment
+    attr_reader :name
+    delegate :to_s, to: :name
+
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def hash_key
+      HeadMusic::Utilities::HashKey.for(name)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def get_by_name(name)
+        name = name.to_s
+        @instances_by_name ||= {}
+        key = HeadMusic::Utilities::HashKey.for(name)
+        @instances_by_name[key] ||= new(name)
+      end
+    end
+  end
+end

data/lib/head_music/placement.rb

@@ -18,13 +18,19 @@ class HeadMusic::Placement
   end
 
   def next_position
-    position + rhythmic_value
+    @next_position ||= position + rhythmic_value
   end
 
   def <=>(other)
     self.position <=> other.position
   end
 
+  def during?(other_placement)
+    (other_placement.position >= position && other_placement.position < next_position) ||
+    (other_placement.next_position > position && other_placement.next_position <= next_position) ||
+    (other_placement.position <= position && other_placement.next_position >= next_position)
+  end
+
   private
 
   def ensure_attributes(voice, position, rhythmic_value, pitch)

data/lib/head_music/position.rb

@@ -3,17 +3,20 @@ class HeadMusic::Position
 
   attr_reader :composition, :bar_number, :count, :tick
   delegate :to_s, to: :code
-  delegate :meter, to: :composition
 
   def initialize(composition, code_or_bar, count = nil, tick = nil)
     if code_or_bar.is_a?(String) && code_or_bar =~ /\D/
-      bar, count, tick = code_or_bar.split(/\D+/)
-      ensure_state(composition, bar, count, tick)
+      bar_number, count, tick = code_or_bar.split(/\D+/)
+      ensure_state(composition, bar_number, count, tick)
     else
       ensure_state(composition, code_or_bar, count, tick)
     end
   end
 
+  def meter
+    composition.meter_at(bar_number)
+  end
+
   def code
     tick_string = tick.to_s.rjust(3, '0')
     [bar_number, count, tick_string].join(':')
@@ -27,6 +30,10 @@ class HeadMusic::Position
     [bar_number, count, tick]
   end
 
+  def within_placement?(placement)
+    placement.position <= self && placement.next_position > self
+  end
+
   def <=>(other)
     if other.is_a?(String) && other =~ /\D/
       other = self.class.new(composition, other)
@@ -73,7 +80,6 @@ class HeadMusic::Position
   end
 
   def roll_over_ticks
-    # TODO account for meter changes in bars
     while @tick >= meter.ticks_per_count
       @tick -= meter.ticks_per_count.to_i
       @count += 1
@@ -81,7 +87,6 @@ class HeadMusic::Position
   end
 
   def roll_over_counts
-    # TODO account for meter changes in bars
     while @count > meter.counts_per_bar
       @count -= meter.counts_per_bar
       @bar_number += 1

data/lib/head_music/rhythmic_unit.rb

@@ -1,27 +1,26 @@
 class HeadMusic::RhythmicUnit
+  include HeadMusic::NamedRudiment
+
   MULTIPLES = ['whole', 'double whole', 'longa', 'maxima']
   FRACTIONS = ['whole', 'half', 'quarter', 'eighth', 'sixteenth', 'thirty-second', 'sixty-fourth', 'hundred twenty-eighth', 'two hundred fifty-sixth']
 
   BRITISH_MULTIPLE_NAMES = %w[semibreve breve longa maxima]
   BRITISH_DIVISION_NAMES = %w[semibreve minim crotchet quaver semiquaver demisemiquaver hemidemisemiquaver semihemidemisemiquaver demisemihemidemisemiquaver]
 
-  def self.get(name)
-    @rhythmic_units ||= {}
-    hash_key = HeadMusic::Utilities::HashKey.for(name)
-    @rhythmic_units[hash_key] ||= new(name.to_s)
-  end
-
   def self.for_denominator_value(denominator)
     get(FRACTIONS[Math.log2(denominator).to_i])
   end
 
-  attr_reader :name, :numerator, :denominator
-  delegate :to_s, to: :name
+  attr_reader :numerator, :denominator
+
+  def self.get(name)
+    get_by_name(name)
+  end
 
   def initialize(canonical_name)
     @name ||= canonical_name
-    @numerator ||= MULTIPLES.include?(name) ? 2**MULTIPLES.index(name) : 1
-    @denominator ||= FRACTIONS.include?(name) ? 2**FRACTIONS.index(name) : 1
+    @numerator = 2**numerator_exponent
+    @denominator = 2**denominator_exponent
   end
 
   def relative_value
@@ -60,8 +59,20 @@ class HeadMusic::RhythmicUnit
       BRITISH_MULTIPLE_NAMES[MULTIPLES.index(name)]
     elsif FRACTIONS.include?(name)
       BRITISH_DIVISION_NAMES[FRACTIONS.index(name)]
+    elsif BRITISH_MULTIPLE_NAMES.include?(name) || BRITISH_DIVISION_NAMES.include?(name)
+      name
     end
   end
 
   private_class_method :new
+
+  private
+
+  def numerator_exponent
+    MULTIPLES.index(name) || BRITISH_MULTIPLE_NAMES.index(name) || 0
+  end
+
+  def denominator_exponent
+    FRACTIONS.index(name) || BRITISH_DIVISION_NAMES.index(name) || 0
+  end
 end