head_music 0.10.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3c4a7d9f36e3a577a3b3e15dde8e3b9b8719937
-  data.tar.gz: dc196e99e9f17077d7135fb17047a07a8fee13be
+  metadata.gz: 349d91b0d02df9a4722f7634e1f8d99a9849a2c0
+  data.tar.gz: 3ec53a83af4f774862d3613a4984c313b5f3ea68
 SHA512:
-  metadata.gz: 1fa70d04a30f7f652420d88224192f4a2dd89a8436a363a3306129336d3a61a390ecd0d4c8baf2a7ca9cd05798dc4bbd09e0969bf0107335a7adaa3a3ae7f195
-  data.tar.gz: 95a836da90aa931b77935d7558c2fb6710b9b559ec69578b39451655551e058bfa19ef68fdea8541dbb24912011d34490d61e34f9baf4eff65f22fd8fec48f85
+  metadata.gz: 69b19f4ba6c53650588b961fd05dda708050a79134442ea0530e7608e6e6eebe877fce5f4dd72b4e002fc8db4ae3280d5a9220b7ca65b511cefbcb4b25c4f539
+  data.tar.gz: bcd8464c13c4cfcaddc8a91f1a11e657f3cebe34cba000b067a8c7554774f921fdd822deead34a01479495201c8db9f5d3dc0d75d335d2f8cadec12f37c2f19a

data/lib/head_music/chord.rb

@@ -0,0 +1,29 @@
+class HeadMusic::Chord
+  attr_reader :pitches
+
+  def initialize(pitches)
+    raise ArgumentError if pitches.length < 3
+    @pitches = pitches.map { |pitch| Pitch.get(pitch) }.sort
+  end
+
+  def consonant_triad?
+    pitches.length == 3 &&
+    (
+      intervals.map(&:shorthand).sort == %w[M3 m3] ||
+      invert.intervals.map(&:shorthand).sort == %w[M3 m3] ||
+      invert.invert.intervals.map(&:shorthand).sort == %w[M3 m3]
+    )
+  end
+
+  def intervals
+    pitches[1..-1].map.with_index do |pitch, i|
+      FunctionalInterval.new(pitches[i], pitch)
+    end
+  end
+
+  def invert
+    inverted_pitch = pitches[0] + HeadMusic::Interval.get(12)
+    new_pitches = pitches[1..-1] + [inverted_pitch]
+    HeadMusic::Chord.new(new_pitches)
+  end
+end

data/lib/head_music/composition.rb

@@ -1,7 +1,7 @@
 class HeadMusic::Composition
   attr_reader :name, :key_signature, :meter, :bars, :voices
 
-  def initialize(name:, key_signature: nil, meter: nil)
+  def initialize(name: nil, key_signature: nil, meter: nil)
     ensure_attributes(name, key_signature, meter)
     add_bar
     add_voice
@@ -26,7 +26,7 @@ class HeadMusic::Composition
   private
 
   def ensure_attributes(name, key_signature, meter)
-    @name = name
+    @name = name || 'Composition'
     @key_signature = HeadMusic::KeySignature.get(key_signature) if key_signature
     @key_signature ||= HeadMusic::KeySignature.default
     @meter = HeadMusic::Meter.get(meter) if meter

data/lib/head_music/consonance.rb

@@ -14,6 +14,10 @@ class HeadMusic::Consonance
     @name = name.to_s.to_sym
   end
 
+  def ==(other)
+    self.to_s == other.to_s
+  end
+
   LEVELS.each do |method_name|
     define_method(:"#{method_name}?") { to_s == method_name }
   end

data/lib/head_music/functional_interval.rb

@@ -121,7 +121,7 @@ class HeadMusic::FunctionalInterval
     if number < NUMBER_NAMES.length
       [quality_name, number_name].join(' ')
     elsif simple_name == 'perfect unison'
-      string = "#{octaves.humanize} octaves"
+      "#{octaves.humanize} octaves"
     else
       "#{octaves.humanize} octaves and #{quality.article} #{simple_name}"
     end
@@ -160,18 +160,18 @@ class HeadMusic::FunctionalInterval
     HeadMusic::FunctionalInterval.new(higher_pitch, inverted_low_pitch)
   end
 
-  def consonance
-    if quality.perfect?
-      if [number, simple_number].include?(4)
+  def consonance(style = :standard_practice)
+    if perfect?
+      if fourth? && style == :two_part_harmony
         HeadMusic::Consonance.get(:dissonant)
       else
         HeadMusic::Consonance.get(:perfect)
       end
-    elsif quality.major? || quality.minor?
-      if [number, simple_number] & [3, 6].empty?
-        HeadMusic::Consonance.get(:dissonant)
-      else
+    elsif major? || minor?
+      if third? || sixth?
         HeadMusic::Consonance.get(:imperfect)
+      else
+        HeadMusic::Consonance.get(:dissonant)
       end
     else
       HeadMusic::Consonance.get(:dissonant)
@@ -189,12 +189,13 @@ class HeadMusic::FunctionalInterval
   def leap?
     number > 3
   end
+  alias_method :large_leap?, :leap?
 
   def ==(other)
     self.to_s.gsub(/\W/, '_') == other.to_s.gsub(/\W/, '_')
   end
 
   NUMBER_NAMES.each do |method_name|
-    define_method(:"#{method_name}?") { number_name == method_name }
+    define_method(:"#{method_name}?") { number_name == method_name || simple_number_name == method_name }
   end
 end

data/lib/head_music/key_signature.rb

@@ -30,20 +30,16 @@ class HeadMusic::KeySignature
     @scale = HeadMusic::Scale.get(@tonic_spelling, @scale_type)
   end
 
+  def spellings
+    pitches.map(&:spelling).uniq
+  end
+
   def sharps
-    pitches.map(&:spelling).uniq.select { |spelling|
-      spelling.sharp?
-    }.map(&:to_s).sort_by { |sharp|
-      SHARPS.index(sharp)
-    }
+    spellings.select(&:sharp?).sort_by { |sharp| SHARPS.index(sharp.to_s) }
   end
 
   def flats
-    pitches.map(&:spelling).uniq.select { |spelling|
-      spelling.flat?
-    }.map(&:to_s).sort_by { |flat|
-      FLATS.index(flat)
-    }
+    spellings.select(&:flat?).sort_by { |flat| FLATS.index(flat.to_s) }
   end
 
   def num_sharps

data/lib/head_music/letter_name.rb

@@ -29,7 +29,7 @@ class HeadMusic::LetterName
     @letter_names ||= {}
     return nil if pitch_class.to_s == pitch_class
     pitch_class = pitch_class.to_i % 12
-    name = NAMES.detect { |name| pitch_class == NATURAL_PITCH_CLASS_NUMBERS[name] }
+    name = NAMES.detect { |candidate| pitch_class == NATURAL_PITCH_CLASS_NUMBERS[candidate] }
     name ||= HeadMusic::PitchClass::SHARP_SPELLINGS[pitch_class].first
     @letter_names[name] ||= new(name) if NAMES.include?(name)
   end

data/lib/head_music/melodic_interval.rb

@@ -19,6 +19,14 @@ class HeadMusic::MelodicInterval
     second_note.next_position
   end
 
+  def notes
+    [first_note, second_note]
+  end
+
+  def pitches
+    notes.map(&:pitch)
+  end
+
   def to_s
     [direction, functional_interval].join(' ')
   end

data/lib/head_music/meter.rb

@@ -7,7 +7,7 @@ class HeadMusic::Meter
   }
 
   def self.get(identifier)
-    identifer = identifer.to_s
+    identifier = identifier.to_s
     hash_key = HeadMusic::Utilities::HashKey.for(identifier)
     time_signature_string = NAMED[hash_key] || identifier
     @meters ||= {}

data/lib/head_music/rhythmic_value.rb

@@ -56,7 +56,7 @@ class HeadMusic::RhythmicValue
   end
 
   def multiplier
-    (0..dots).reduce(0) { |sum, i| sum += (1.0/2)**i }
+    (0..dots).reduce(0) { |sum, i| sum + (1.0/2)**i }
   end
 
   def ticks

data/lib/head_music/scale.rb

@@ -27,12 +27,11 @@ class HeadMusic::Scale
   end
 
   def determine_scale_pitches(direction, octaves)
-    letter_name_cycle = root_pitch.letter_name_cycle
     semitones_from_root = 0
     [root_pitch].tap do |pitches|
       [:ascending, :descending].each do |single_direction|
         if [single_direction, :both].include?(direction)
-          (1..octaves).each do |i|
+          (1..octaves).each do
             direction_intervals(single_direction).each_with_index do |semitones, i|
               semitones_from_root += semitones * direction_sign(single_direction)
               pitches << pitch_for_step(i+1, semitones_from_root, single_direction)

data/lib/head_music/scale_type.rb

@@ -60,9 +60,9 @@ class HeadMusic::ScaleType
 
   def self.get(name)
     @scale_types ||= {}
-    name = name.to_s.to_sym
-    attributes = SCALE_TYPES[name]
-    @scale_types[name] ||= new(name, attributes)
+    identifier = HeadMusic::Utilities::HashKey.for(name)
+    attributes = SCALE_TYPES[identifier]
+    @scale_types[identifier] ||= new(identifier, attributes)
   end
 
   def self.default

data/lib/head_music/spelling.rb

@@ -37,8 +37,8 @@ class HeadMusic::Spelling
 
   def self.from_number_and_letter(number, letter_name)
     letter_name = HeadMusic::LetterName.get(letter_name)
-    natural_letter_pitch_class = HeadMusic::LetterName.get(letter_name).pitch_class
-    accidental_interval = letter_name.pitch_class.smallest_interval_to(HeadMusic::PitchClass.get(number))
+    natural_letter_pitch_class = letter_name.pitch_class
+    accidental_interval = natural_letter_pitch_class.smallest_interval_to(HeadMusic::PitchClass.get(number))
     accidental = HeadMusic::Accidental.for_interval(accidental_interval)
     fetch_or_create(letter_name, accidental)
   end

data/lib/head_music/style/analysis.rb

@@ -6,7 +6,10 @@ module HeadMusic
       def initialize(ruleset, subject)
         @ruleset = ruleset
         @subject = subject
-        @annotations = @ruleset.analyze(subject)
+      end
+
+      def annotations
+        @annotations ||= @ruleset.analyze(subject)
       end
 
       def fitness

data/lib/head_music/style/annotation.rb

@@ -1,28 +1,32 @@
 class HeadMusic::Style::Annotation
-  attr_reader :fitness, :message, :marks, :subject
+  attr_reader :voice
 
-  def initialize(subject:, fitness:, message: nil, marks: nil)
-    @subject = subject
-    @fitness = fitness
-    @message = message
-    @marks = [marks].flatten.compact
-  end
+  delegate(
+    :composition,
+    :highest_notes,
+    :lowest_notes,
+    :melodic_intervals,
+    :notes,
+    :notes_not_in_key,
+    :placements,
+    :range,
+    :rests,
+    to: :voice
+  )
 
-  def voice
-    subject if subject.is_a?(HeadMusic::Voice)
+  def initialize(voice)
+    @voice = voice
   end
 
-  def composition
-    voice ? voice.composition : subject
+  def fitness
+    [marks].flatten.compact.map(&:fitness).reduce(1, :*)
   end
 
-  def marks_count
-    marks ? marks.length : 0
+  def marks
+    raise NotImplementedError
   end
 
-  def first_mark_code
-    marks.first.code if marks.first
+  def message
+    raise NotImplementedError
   end
-
-  alias_method :to_s, :message
 end

data/lib/head_music/style/annotations/always_move.rb

@@ -0,0 +1,16 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::AlwaysMove < HeadMusic::Style::Annotation
+  def message
+    "Always move to a different note."
+  end
+
+  def marks
+    melodic_intervals.map.with_index do |interval, i|
+      if interval.shorthand == 'PU'
+        HeadMusic::Style::Mark.for_all(notes[i..i+1])
+      end
+    end.reject(&:nil?)
+  end
+end

data/lib/head_music/style/annotations/at_least_eight_notes.rb

@@ -0,0 +1,31 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::AtLeastEightNotes < HeadMusic::Style::Annotation
+  MINIMUM_NOTES = 8
+
+  def message
+    "Write at least eight notes."
+  end
+
+  def marks
+    placements.empty? ? no_placements_mark : deficiency_mark
+  end
+
+  private
+
+  def no_placements_mark
+    return Style::Mark.new(
+      Position.new(composition, "1:1"),
+      Position.new(composition, "2:1"),
+      fitness: HeadMusic::PENALTY_FACTOR**MINIMUM_NOTES
+    )
+  end
+
+  def deficiency_mark
+    deficiency = [MINIMUM_NOTES - notes.length, 0].max
+    if deficiency > 0
+      Style::Mark.for_all(placements, fitness: HeadMusic::PENALTY_FACTOR**deficiency)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::ConsonantClimax < HeadMusic::Style::Annotation
+  def message
+    "Peak on a consonant high note one time."
+  end
+
+  def marks
+    if notes
+      improper_climaxes = highest_notes.select.with_index do |note, i|
+        tonic_pitch = Pitch.get(composition.key_signature.tonic_spelling)
+        interval = FunctionalInterval.new(tonic_pitch, note.pitch)
+        interval.consonance.dissonant? || i > 0
+      end
+      HeadMusic::Style::Mark.for_each(improper_climaxes)
+    end
+  end
+end

data/lib/head_music/style/annotations/diatonic.rb

@@ -0,0 +1,12 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::Diatonic < HeadMusic::Style::Annotation
+  def message
+    "Use only notes in the key signature."
+  end
+
+  def marks
+    HeadMusic::Style::Mark.for_each(notes_not_in_key)
+  end
+end

data/lib/head_music/style/annotations/direction_changes.rb

@@ -0,0 +1,35 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::DirectionChanges < HeadMusic::Style::Annotation
+  MAXIMUM_NOTES_PER_DIRECTION = 3
+
+  def message
+    "Balance ascending and descending motion."
+  end
+
+  def marks
+    if overage > 0
+      penalty_exponent = overage**0.5
+      HeadMusic::Style::Mark.for_all(notes, fitness: PENALTY_FACTOR**penalty_exponent)
+    end
+  end
+
+  private
+
+  def overage
+    return 0 if notes.length < 2
+    [notes_per_direction - MAXIMUM_NOTES_PER_DIRECTION, 0].max
+  end
+
+  def notes_per_direction
+    notes.length.to_f / (melodic_intervals_changing_direction.length + 1)
+  end
+
+  def melodic_intervals_changing_direction
+    melodic_intervals[1..-1].select.with_index do |interval, i|
+      previous_direction = melodic_intervals[i].direction
+      interval.direction != previous_direction
+    end
+  end
+end

data/lib/head_music/style/annotations/end_on_tonic.rb

@@ -0,0 +1,24 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::EndOnTonic < HeadMusic::Style::Annotation
+  def message
+    'End on the tonic.'
+  end
+
+  def marks
+    if !notes.empty? && !ends_on_tonic?
+      HeadMusic::Style::Mark.for(notes.last)
+    end
+  end
+
+  private
+
+  def ends_on_tonic?
+    notes &&
+    notes.last &&
+    composition &&
+    composition.key_signature &&
+    composition.key_signature.tonic_spelling == notes.last.spelling
+  end
+end

data/lib/head_music/style/annotations/limit_range.rb

@@ -0,0 +1,26 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::LimitRange < HeadMusic::Style::Annotation
+  MAXIMUM_RANGE = 10
+
+  def message
+    'Limit melodic range to a 10th.'
+  end
+
+  def marks
+    if overage > 0
+      HeadMusic::Style::Mark.for_each(extremes, fitness: HeadMusic::PENALTY_FACTOR**overage)
+    end
+  end
+
+  private
+
+  def overage
+    notes.length > 0 ? [range.number - MAXIMUM_RANGE, 0].max : 0
+  end
+
+  def extremes
+    (highest_notes + lowest_notes).sort
+  end
+end

data/lib/head_music/style/annotations/mostly_conjunct.rb

@@ -0,0 +1,26 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::MostlyConjunct < HeadMusic::Style::Annotation
+  def message
+    "Use mostly conjunct motion."
+  end
+
+  def marks
+    marks_for_skips_and_leaps if conjunct_ratio <= 0.5
+  end
+
+  private
+
+  def marks_for_skips_and_leaps
+    melodic_intervals.map.with_index do |interval, i|
+      HeadMusic::Style::Mark.for_all(notes[i..i+1], fitness: HeadMusic::SMALL_PENALTY_FACTOR) unless interval.step?
+    end.reject(&:nil?)
+  end
+
+  def conjunct_ratio
+    return 1 if melodic_intervals.empty?
+    steps = melodic_intervals.count { |interval| interval.step? }
+    steps.to_f / melodic_intervals.length
+  end
+end

data/lib/head_music/style/annotations/no_rests.rb

@@ -0,0 +1,12 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::NoRests < HeadMusic::Style::Annotation
+  def message
+    "Use only notes."
+  end
+
+  def marks
+    rests.map { |rest| HeadMusic::Style::Mark.for(rest) }
+  end
+end

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

@@ -0,0 +1,45 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::NotesSameLength < HeadMusic::Style::Annotation
+  def message
+    'Use consistent rhythmic unit.'
+  end
+
+  def marks
+    preferred_value = first_most_common_rhythmic_value
+    wrong_length_notes = all_but_last_note.select { |note| note.rhythmic_value != preferred_value }
+    HeadMusic::Style::Mark.for_each(wrong_length_notes)
+  end
+
+  private
+
+  def all_but_last_note
+    notes[0..-2]
+  end
+
+  def distinct_values
+    all_but_last_note.map(&:rhythmic_value).uniq.length
+  end
+
+  def first_most_common_rhythmic_value
+    candidates = most_common_rhythmic_values
+    first_match = notes.detect { |note| candidates.include?(note.rhythmic_value) }
+    first_match ? first_match.rhythmic_value : nil
+  end
+
+  def most_common_rhythmic_values
+    return [] if notes.empty?
+    occurrences = occurrences_by_rhythmic_value
+    highest_count = occurrences.values.sort.last
+    occurrences.select { |_rhythmic_value, count| count == highest_count }.keys
+  end
+
+  def occurrences_by_rhythmic_value
+    rhythmic_values.inject(Hash.new(0)) { |hash, value| hash[value] += 1; hash }
+  end
+
+  def rhythmic_values
+    notes.map(&:rhythmic_value)
+  end
+end

data/lib/head_music/style/annotations/permitted_intervals.rb

@@ -0,0 +1,27 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::PermittedIntervals < HeadMusic::Style::Annotation
+  PERMITTED_ASCENDING = %w[m2 M2 m3 M3 P4 P5 m6 P8]
+  PERMITTED_DESCENDING = %w[m2 M2 m3 M3 P4 P5 P8]
+
+  def message
+    "Use only m2, M2, m3, M3, P4, P5, m6 (ascending), P8."
+  end
+
+  def marks
+    melodic_intervals.reject { |interval| permitted?(interval) }.map do |unpermitted_interval|
+      HeadMusic::Style::Mark.for_all([unpermitted_interval.first_note, unpermitted_interval.second_note])
+    end
+  end
+
+  private
+
+  def permitted?(melodic_interval)
+    whitelist_for_interval(melodic_interval).include?(melodic_interval.shorthand)
+  end
+
+  def whitelist_for_interval(melodic_interval)
+    melodic_interval.ascending? ? PERMITTED_ASCENDING : PERMITTED_DESCENDING
+  end
+end

data/lib/head_music/style/annotations/recover_large_leaps.rb

@@ -0,0 +1,44 @@
+module HeadMusic::Style::Annotations
+end
+
+# Ok, so a rule might be that after the first leap (after previous steps)
+# one should normally move by step in the opposite direction
+# unless another leap (in either direction) creates a consonant triad.
+# - Brian
+class HeadMusic::Style::Annotations::RecoverLargeLeaps < HeadMusic::Style::Annotation
+  def message
+    "Recover leaps by step in the opposite direction."
+  end
+
+  def marks
+    melodic_intervals[1..-1].to_a.map.with_index do |interval, i|
+      previous_interval = melodic_intervals[i]
+      if unrecovered_leap?(previous_interval, interval)
+        HeadMusic::Style::Mark.for_all((previous_interval.notes + interval.notes).uniq)
+      end
+    end.reject(&:nil?)
+  end
+
+  private
+
+  def unrecovered_leap?(first_interval, second_interval)
+    first_interval.leap? &&
+    !spelling_consonant_triad?(first_interval, second_interval) &&
+    (
+      !direction_changed?(first_interval, second_interval) ||
+      !second_interval.step?
+    )
+  end
+
+  def spelling_consonant_triad?(first_interval, second_interval)
+    return false if first_interval.step? || second_interval.step?
+    pitches = (first_interval.pitches + second_interval.pitches).uniq
+    return false if pitches.length < 3
+    HeadMusic::Chord.new(pitches).consonant_triad?
+  end
+
+  def direction_changed?(first_interval, second_interval)
+    first_interval.ascending? && second_interval.descending? ||
+      first_interval.descending? && second_interval.ascending?
+  end
+end

data/lib/head_music/style/annotations/start_on_tonic.rb

@@ -0,0 +1,22 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::StartOnTonic < HeadMusic::Style::Annotation
+  def message
+    'Start on the tonic.'
+  end
+
+  def marks
+    if first_note && !starts_on_tonic?
+      HeadMusic::Style::Mark.for(first_note)
+    end
+  end
+
+  def starts_on_tonic?
+    composition.key_signature.tonic_spelling == first_note.spelling
+  end
+
+  def first_note
+    notes.first
+  end
+end

data/lib/head_music/style/annotations/step_down_to_final_note.rb

@@ -0,0 +1,33 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::StepDownToFinalNote < HeadMusic::Style::Annotation
+  def message
+    'Step down to final note.'
+  end
+
+  def marks
+    if !last_melodic_interval.nil?
+      fitness = 1
+      fitness *= HeadMusic::PENALTY_FACTOR unless step?
+      fitness *= HeadMusic::PENALTY_FACTOR unless descending?
+      if fitness < 1
+        HeadMusic::Style::Mark.for_all(notes[-2..-1], fitness: fitness)
+      end
+    end
+  end
+
+  private
+
+  def descending?
+    last_melodic_interval && last_melodic_interval.descending?
+  end
+
+  def step?
+    last_melodic_interval && last_melodic_interval.step?
+  end
+
+  def last_melodic_interval
+    @last_melodic_interval ||= melodic_intervals.last
+  end
+end

data/lib/head_music/style/annotations/up_to_thirteen_notes.rb

@@ -0,0 +1,22 @@
+module HeadMusic::Style::Annotations
+end
+
+class HeadMusic::Style::Annotations::UpToThirteenNotes < HeadMusic::Style::Annotation
+  MAXIMUM_NOTES = 13
+
+  def message
+    'Write up to thirteen notes.'
+  end
+
+  def marks
+    if overage > 0
+      Style::Mark.for_all(notes[13..-1])
+    end
+  end
+
+  private
+
+  def overage
+    [notes.length - MAXIMUM_NOTES, 0].max
+  end
+end

data/lib/head_music/style/mark.rb

@@ -1,26 +1,27 @@
 class HeadMusic::Style::Mark
-  attr_reader :start_position, :end_position, :placements
+  attr_reader :start_position, :end_position, :placements, :fitness
 
-  def self.for(placement)
-    new(placement.position, placement.next_position, placement)
+  def self.for(placement, fitness: nil)
+    new(placement.position, placement.next_position, placements: [placement], fitness: fitness)
   end
 
-  def self.for_all(placements)
+  def self.for_all(placements, fitness: nil)
     placements = [placements].flatten
     start_position = placements.map { |placement| placement.position }.sort.first
     end_position = placements.map { |placement| placement.next_position }.sort.last
-    new(start_position, end_position, placements)
+    new(start_position, end_position, placements: placements, fitness: fitness)
   end
 
-  def self.for_each(placements)
+  def self.for_each(placements, fitness: nil)
     placements = [placements].flatten
-    placements.map { |placement| new(placement.position, placement.next_position, placement) }
+    placements.map { |placement| new(placement.position, placement.next_position, placements: placement, fitness: fitness) }
   end
 
-  def initialize(start_position, end_position, placements = [])
+  def initialize(start_position, end_position, placements: [], fitness: nil)
     @start_position = start_position
     @end_position = end_position
-    @placements = [placements].flatten
+    @placements = [placements].flatten.compact
+    @fitness = fitness || HeadMusic::PENALTY_FACTOR
   end
 
   def code

data/lib/head_music/style/rulesets/cantus_firmus.rb

@@ -3,20 +3,24 @@ end
 
 class HeadMusic::Style::Rulesets::CantusFirmus
   RULESET = [
-    HeadMusic::Style::Rules::AlwaysMove,
-    HeadMusic::Style::Rules::AtLeastEightNotes,
-    HeadMusic::Style::Rules::Diatonic,
-    HeadMusic::Style::Rules::EndOnTonic,
-    HeadMusic::Style::Rules::LimitRange,
-    HeadMusic::Style::Rules::MostlyConjunct,
-    HeadMusic::Style::Rules::NoRests,
-    HeadMusic::Style::Rules::NotesSameLength,
-    HeadMusic::Style::Rules::StartOnTonic,
-    HeadMusic::Style::Rules::StepDownToFinalNote,
-    HeadMusic::Style::Rules::UpToThirteenNotes,
+    HeadMusic::Style::Annotations::AlwaysMove,
+    HeadMusic::Style::Annotations::AtLeastEightNotes,
+    HeadMusic::Style::Annotations::ConsonantClimax,
+    HeadMusic::Style::Annotations::Diatonic,
+    HeadMusic::Style::Annotations::DirectionChanges,
+    HeadMusic::Style::Annotations::EndOnTonic,
+    HeadMusic::Style::Annotations::LimitRange,
+    HeadMusic::Style::Annotations::MostlyConjunct,
+    HeadMusic::Style::Annotations::NoRests,
+    HeadMusic::Style::Annotations::NotesSameLength,
+    HeadMusic::Style::Annotations::PermittedIntervals,
+    HeadMusic::Style::Annotations::RecoverLargeLeaps,
+    HeadMusic::Style::Annotations::StartOnTonic,
+    HeadMusic::Style::Annotations::StepDownToFinalNote,
+    HeadMusic::Style::Annotations::UpToThirteenNotes,
   ]
 
   def self.analyze(voice)
-    RULESET.map { |rule| rule.analyze(voice) }
+    RULESET.map { |rule| rule.new(voice) }
   end
 end

data/lib/head_music/version.rb

@@ -1,3 +1,3 @@
 module HeadMusic
-  VERSION = "0.10.0"
+  VERSION = "0.11.1"
 end

data/lib/head_music/voice.rb

@@ -5,7 +5,7 @@ class HeadMusic::Voice
   delegate :key_signature, to: :composition
 
   def initialize(composition: nil, role: nil)
-    @composition = composition || Composition.new(name: "Composition")
+    @composition = composition || Composition.new
     @role = role
     @placements = []
   end
@@ -59,6 +59,10 @@ class HeadMusic::Voice
     end.reject(&:nil?)
   end
 
+  def leaps
+    melodic_intervals.select(&:leap?)
+  end
+
   private
 
   def insert_into_placements(placement)

data/lib/head_music.rb

@@ -6,6 +6,7 @@ require 'humanize'
 
 require 'head_music/accidental'
 require 'head_music/bar'
+require 'head_music/chord'
 require 'head_music/circle'
 require 'head_music/clef'
 require 'head_music/composition'
@@ -36,19 +37,22 @@ require 'head_music/staff'
 require 'head_music/style/analysis'
 require 'head_music/style/annotation'
 require 'head_music/style/mark'
-require 'head_music/style/rule'
 
-require 'head_music/style/rules/always_move'
-require 'head_music/style/rules/at_least_eight_notes'
-require 'head_music/style/rules/diatonic'
-require 'head_music/style/rules/end_on_tonic'
-require 'head_music/style/rules/limit_range'
-require 'head_music/style/rules/mostly_conjunct'
-require 'head_music/style/rules/no_rests'
-require 'head_music/style/rules/notes_same_length'
-require 'head_music/style/rules/start_on_tonic'
-require 'head_music/style/rules/step_down_to_final_note'
-require 'head_music/style/rules/up_to_thirteen_notes'
+require 'head_music/style/annotations/always_move'
+require 'head_music/style/annotations/at_least_eight_notes'
+require 'head_music/style/annotations/consonant_climax'
+require 'head_music/style/annotations/diatonic'
+require 'head_music/style/annotations/direction_changes'
+require 'head_music/style/annotations/end_on_tonic'
+require 'head_music/style/annotations/limit_range'
+require 'head_music/style/annotations/mostly_conjunct'
+require 'head_music/style/annotations/no_rests'
+require 'head_music/style/annotations/notes_same_length'
+require 'head_music/style/annotations/permitted_intervals'
+require 'head_music/style/annotations/recover_large_leaps'
+require 'head_music/style/annotations/start_on_tonic'
+require 'head_music/style/annotations/step_down_to_final_note'
+require 'head_music/style/annotations/up_to_thirteen_notes'
 
 require 'head_music/style/rulesets/cantus_firmus'
 
@@ -58,4 +62,6 @@ require 'head_music/voice'
 module HeadMusic
   GOLDEN_RATIO = (1 + 5**0.5) / 2.0
   GOLDEN_RATIO_INVERSE = 1 / GOLDEN_RATIO
+  PENALTY_FACTOR = GOLDEN_RATIO_INVERSE
+  SMALL_PENALTY_FACTOR = GOLDEN_RATIO_INVERSE**0.5
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: head_music
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Rob Head
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -118,6 +118,7 @@ files:
 - lib/head_music.rb
 - lib/head_music/accidental.rb
 - lib/head_music/bar.rb
+- lib/head_music/chord.rb
 - lib/head_music/circle.rb
 - lib/head_music/clef.rb
 - lib/head_music/composition.rb
@@ -146,19 +147,22 @@ files:
 - lib/head_music/staff.rb
 - lib/head_music/style/analysis.rb
 - lib/head_music/style/annotation.rb
+- lib/head_music/style/annotations/always_move.rb
+- lib/head_music/style/annotations/at_least_eight_notes.rb
+- lib/head_music/style/annotations/consonant_climax.rb
+- lib/head_music/style/annotations/diatonic.rb
+- lib/head_music/style/annotations/direction_changes.rb
+- lib/head_music/style/annotations/end_on_tonic.rb
+- lib/head_music/style/annotations/limit_range.rb
+- lib/head_music/style/annotations/mostly_conjunct.rb
+- lib/head_music/style/annotations/no_rests.rb
+- lib/head_music/style/annotations/notes_same_length.rb
+- lib/head_music/style/annotations/permitted_intervals.rb
+- lib/head_music/style/annotations/recover_large_leaps.rb
+- lib/head_music/style/annotations/start_on_tonic.rb
+- lib/head_music/style/annotations/step_down_to_final_note.rb
+- lib/head_music/style/annotations/up_to_thirteen_notes.rb
 - lib/head_music/style/mark.rb
-- lib/head_music/style/rule.rb
-- lib/head_music/style/rules/always_move.rb
-- lib/head_music/style/rules/at_least_eight_notes.rb
-- lib/head_music/style/rules/diatonic.rb
-- lib/head_music/style/rules/end_on_tonic.rb
-- lib/head_music/style/rules/limit_range.rb
-- lib/head_music/style/rules/mostly_conjunct.rb
-- lib/head_music/style/rules/no_rests.rb
-- lib/head_music/style/rules/notes_same_length.rb
-- lib/head_music/style/rules/start_on_tonic.rb
-- lib/head_music/style/rules/step_down_to_final_note.rb
-- lib/head_music/style/rules/up_to_thirteen_notes.rb
 - lib/head_music/style/rulesets/cantus_firmus.rb
 - lib/head_music/utilities/hash_key.rb
 - lib/head_music/version.rb

data/lib/head_music/style/rule.rb

@@ -1,13 +0,0 @@
-class HeadMusic::Style::Rule
-  # returns a score between 0 and 1
-  # Note: absence of a problem or 'not applicable' should score as a 1.
-  # for example, if the rule is to end on the tonic,
-  #   a composition with no notes should count as a 1.
-  def fitness(object)
-    raise NotImplementedError, 'A fitness method is required for all style rules.'
-  end
-
-  def self.annotations(object)
-    raise NotImplementedError, 'An annotations method is required for all style rules.'
-  end
-end

data/lib/head_music/style/rules/always_move.rb

@@ -1,19 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::AlwaysMove < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    marks = marks(voice)
-    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**marks.length
-    message = "Always move to another note." if fitness < 1
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-
-  def self.marks(voice)
-    voice.melodic_intervals.map.with_index do |interval, i|
-      if interval.shorthand == 'PU'
-        HeadMusic::Style::Mark.for_all(voice.notes[i..i+1])
-      end
-    end.reject(&:nil?)
-  end
-end

data/lib/head_music/style/rules/at_least_eight_notes.rb

@@ -1,26 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::AtLeastEightNotes < HeadMusic::Style::Rule
-  MINIMUM_NOTES = 8
-
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    mark = mark(voice)
-    message = "Add notes until you have at least eight notes." if fitness < 1
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
-  end
-
-  def self.fitness(voice)
-    deficiency = MINIMUM_NOTES - voice.notes.length
-    deficiency > 0 ? HeadMusic::GOLDEN_RATIO_INVERSE**deficiency : 1
-  end
-
-  def self.mark(voice)
-    if voice.placements.empty?
-      Style::Mark.new(Position.new(voice.composition, "1:1"), Position.new(voice.composition, "2:1"))
-    else
-      Style::Mark.for_all(voice.placements)
-    end
-  end
-end

data/lib/head_music/style/rules/diatonic.rb

@@ -1,15 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::Diatonic < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    marks = marks(voice)
-    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**marks.length
-    message = "Use only notes in the key signature." if fitness < 1
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-
-  def self.marks(voice)
-    HeadMusic::Style::Mark.for_each(voice.notes_not_in_key)
-  end
-end

data/lib/head_music/style/rules/end_on_tonic.rb

@@ -1,27 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::EndOnTonic < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      message = 'End on the tonic'
-      mark = HeadMusic::Style::Mark.for(voice.notes.last)
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
-  end
-
-  def self.fitness(voice)
-    return 1 if voice.notes.empty?
-    return 1 if ends_on_tonic?(voice)
-    HeadMusic::GOLDEN_RATIO_INVERSE
-  end
-
-  def self.ends_on_tonic?(voice)
-    voice.notes &&
-    voice.notes.last &&
-    voice.composition &&
-    voice.composition.key_signature &&
-    voice.composition.key_signature.tonic_spelling == voice.notes.last.spelling
-  end
-end

data/lib/head_music/style/rules/limit_range.rb

@@ -1,31 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::LimitRange < HeadMusic::Style::Rule
-  MAXIMUM_RANGE = 10
-
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      message = 'Limit melodic range to a 10th.'
-      marks = marks(voice)
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-
-  def self.fitness(voice)
-    return 1 unless voice.notes.length > 0
-    HeadMusic::GOLDEN_RATIO_INVERSE**overage(voice)
-  end
-
-  def self.overage(voice)
-    voice.notes.length > 0 ? [voice.range.number - MAXIMUM_RANGE, 0].max : 0
-  end
-
-  def self.marks(voice)
-    if voice.notes
-      extremes = (voice.highest_notes + voice.lowest_notes).sort
-      HeadMusic::Style::Mark.for_each(extremes)
-    end
-  end
-end

data/lib/head_music/style/rules/mostly_conjunct.rb

@@ -1,30 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::MostlyConjunct < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      marks = marks(voice)
-      message = "Use only notes in the key signature."
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-
-  def self.fitness(voice)
-    intervals = voice.melodic_intervals.length
-    steps = voice.melodic_intervals.count { |interval| interval.step? }
-    fitness = 1
-    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE if steps.to_f / intervals < 0.5
-    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE if steps.to_f / intervals < 0.25
-    fitness
-  end
-
-  def self.marks(voice)
-    voice.melodic_intervals.map.with_index do |interval, i|
-      if !interval.step?
-        HeadMusic::Style::Mark.for_all(voice.notes[i..i+1])
-      end
-    end
-  end
-end

data/lib/head_music/style/rules/no_rests.rb

@@ -1,14 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::NoRests < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    rests = voice.rests
-    fitness = HeadMusic::GOLDEN_RATIO_INVERSE**rests.length
-    if rests.length > 0
-      message = "Change rests to notes."
-      marks = rests.map { |rest| HeadMusic::Style::Mark.for_all(rest) }
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-end

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

@@ -1,49 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::NotesSameLength < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      message = "Use consistent rhythmic unit."
-    end
-    marks = marks(voice)
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: marks, message: message)
-  end
-
-  def self.fitness(voice)
-    distinct_values = [distinct_values(voice), 1].max
-    HeadMusic::GOLDEN_RATIO_INVERSE**(distinct_values-1)
-  end
-
-  def self.distinct_values(voice)
-    voice.notes[0..-2].map(&:rhythmic_value).uniq.length
-  end
-
-  def self.marks(voice)
-    preferred_value = first_most_common_rhythmic_value(voice)
-    wrong_length_notes = voice.notes.select { |note| note.rhythmic_value != preferred_value }
-    HeadMusic::Style::Mark.for_each(wrong_length_notes)
-  end
-
-  def self.first_most_common_rhythmic_value(voice)
-    candidates = most_common_rhythmic_values(voice)
-    first_match = voice.notes.detect { |note| candidates.include?(note.rhythmic_value) }
-    first_match ? first_match.rhythmic_value : nil
-  end
-
-  def self.most_common_rhythmic_values(voice)
-    return [] if voice.notes.empty?
-    occurrences = occurrences_by_rhythmic_value(voice)
-    highest_count = occurrences.values.sort.last
-    occurrences.select { |rhythmic_value, count| count == highest_count }.keys
-  end
-
-  def self.occurrences_by_rhythmic_value(voice)
-    rhythmic_values(voice).inject(Hash.new(0)) { |hash, value| hash[value] += 1; hash }
-  end
-
-  def self.rhythmic_values(voice)
-    voice.notes.map(&:rhythmic_value)
-  end
-end

data/lib/head_music/style/rules/start_on_tonic.rb

@@ -1,27 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::StartOnTonic < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      message = 'Start on the tonic.'
-      mark = HeadMusic::Style::Mark.for(voice.notes.last)
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
-  end
-
-  def self.fitness(voice)
-    return 1 if voice.notes.empty?
-    return 1 if starts_on_tonic?(voice)
-    HeadMusic::GOLDEN_RATIO_INVERSE
-  end
-
-  def self.starts_on_tonic?(voice)
-    voice.notes &&
-    voice.notes.first &&
-    voice.composition &&
-    voice.composition.key_signature &&
-    voice.composition.key_signature.tonic_spelling == voice.notes.first.spelling
-  end
-end

data/lib/head_music/style/rules/step_down_to_final_note.rb

@@ -1,34 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::StepDownToFinalNote < HeadMusic::Style::Rule
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      message = 'Step down to final note.'
-      mark = HeadMusic::Style::Mark.for_all(voice.notes[-2..-1])
-    end
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
-  end
-
-  def self.fitness(voice)
-    return 1 unless voice.notes.length >= 2
-    fitness = 1
-    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE unless step?(voice)
-    fitness *= HeadMusic::GOLDEN_RATIO_INVERSE unless descending?(voice)
-    fitness
-  end
-
-  def self.descending?(voice)
-    last_melodic_interval(voice).descending?
-  end
-
-  def self.step?(voice)
-    last_melodic_interval(voice).step?
-  end
-
-  def self.last_melodic_interval(voice)
-    @last_melodic_interval ||= {}
-    @last_melodic_interval[voice] ||= voice.melodic_intervals.last
-  end
-end

data/lib/head_music/style/rules/up_to_thirteen_notes.rb

@@ -1,24 +0,0 @@
-module HeadMusic::Style::Rules
-end
-
-class HeadMusic::Style::Rules::UpToThirteenNotes < HeadMusic::Style::Rule
-  MAXIMUM_NOTES = 13
-
-  def self.analyze(voice)
-    fitness = fitness(voice)
-    if fitness < 1
-      mark = mark(voice)
-    end
-    message = "Remove notes until you have at most thirteen notes." if fitness < 1
-    HeadMusic::Style::Annotation.new(subject: voice, fitness: fitness, marks: mark, message: message)
-  end
-
-  def self.fitness(voice)
-    overage = voice.notes.length - MAXIMUM_NOTES
-    overage > 0 ? HeadMusic::GOLDEN_RATIO_INVERSE**overage : 1
-  end
-
-  def self.mark(voice)
-    Style::Mark.for_all(voice.notes[13..-1])
-  end
-end