musicality 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 33617569378085114609e5d277d898ca57e95a98
-  data.tar.gz: a1536b83bd10b7f601e42307f3fc59986e6b1f73
+SHA256:
+  metadata.gz: 04dc7491236652e7000094a669ca7a0b0d06129ad30d5d4080bbbffbb9a41a34
+  data.tar.gz: 68a8829f64fb94c3bc8a011e35e57d891c4677e392b238e5c30f5c1ddbb88cbc
 SHA512:
-  metadata.gz: 669f861d645c18becf4d7a0bf794f7a21862730b76cfb71c57cbc25772a7d72258f16f07b0867a174dd28d1cd9e715fe1b3bf8a6ba9802665ec4099ad40b28cd
-  data.tar.gz: f2ce677c9f05fb3deb00cbc2cac5d8286dc2a5856931c61ff6770e91df3432659ec0ddeb7ddcb6ac853494e91f8c5e9031f3ec31baf6fa7f3f0b9eacdf73c783
+  metadata.gz: d8f17b715734e22ff85594bea1c0d8a6964468a4f4030e2539bea13a3ed8963942b71635dfa552202091f3997833e7d979cbdd2b2b088a33416d1362fc81e93d
+  data.tar.gz: 3280accf4d3f9bb93337b53ae45ef988d9ef54500fd28c124b3da3a988a1c0959f31e6d75c05b120c6936f80620a9fcb0345a3683297f1b527ee304d70644c32

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.ruby-version

@@ -1 +1 @@
-2.0.0
+2.6.5

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.4
+  - jruby

data/ChangeLog.md

@@ -1,3 +1,14 @@
+### 0.12.0 / 2019-11-23
+* Raise ParseError if parse+convert convenience method (to_pitch, to_meter, etc.) fails
+* Simplify Key class
+* Add parsing support for key signatures
+
+### 0.11.2 / 2016-03-29
+* Fix a bug in SuperCollider performance code
+
+### 0.11.1 / 2016-02-18
+* Fix gem description string in .gemspec
+
 ### 0.11.0 / 2016-02-18
 * Fix SuperCollider volume control to output stereo
 * Add :keep_code keyword arg to SuperCollider::Conductor#perform

data/README.md

@@ -1,3 +1,6 @@
+[![Build Status](https://travis-ci.org/jamestunnell/musicality.svg?branch=master)](https://travis-ci.org/jamestunnell/musicality)
+[![Coverage Status](https://coveralls.io/repos/github/jamestunnell/musicality/badge.svg?branch=master)](https://coveralls.io/github/jamestunnell/musicality?branch=master)
+
 # Musicality
 
 The library is based around an abstract representation for music notation. From here, functions are built up to make composing elaborate pieces in this notation representation more manageable. Finally, music performance is supported by providing translation to common formats, like MIDI.

data/Rakefile

@@ -15,7 +15,7 @@ def rb_fname fname
   "#{dirname}/#{basename}.rb"
 end
 
-task :build_parsers do
+def rebuild_parsers force_rebuild
   wd = Dir.pwd
   Dir.chdir "lib/musicality/notation/parsing"
   parser_files = Dir.glob(["**/*.treetop","**/*.tt"])
@@ -27,22 +27,30 @@ task :build_parsers do
 
   build_list = parser_files.select do |fname|
     rb_name = rb_fname(fname)
-    !File.exists?(rb_name) || (File.mtime(fname) > File.mtime(rb_name))
+    force_rebuild || !File.exists?(rb_name) || (File.mtime(fname) > File.mtime(rb_name))
   end
   
   if build_list.any?
     puts "building parsers:"
     build_list.each do |fname|
       puts "  #{fname} -> #{rb_fname(fname)}"
-      `tt -f #{fname}`
+      `bundle exec tt -f #{fname}`
     end
   else
     puts "Parsers are up-to-date"
   end
   Dir.chdir wd
 end
+
+task :build_parsers do
+  rebuild_parsers(false)
+end
 task :spec => :build_parsers
 
+task :rebuild_parsers do
+  rebuild_parsers(true)
+end
+
 task :make_examples do
   current_dir = Dir.getwd
   examples_dir = File.join(File.dirname(__FILE__), 'examples')

data/lib/musicality/composition/model/rhythm.rb

@@ -0,0 +1,33 @@
+module Musicality
+
+# A rhythm based on an array of durations.
+# @note Rests are represented by negative durations.
+class Rhythm
+  attr_reader :durations, :durations_sum
+
+  def initialize durations
+    if durations.find {|x| x.zero? }
+      raise ArgumentError, "rhythm contains duration(s) that are zero"
+    end
+    @durations = durations.clone.freeze
+    @durations_sum = @durations.inject(0) {|sum,x| sum + x.abs}
+  end
+
+  def to_notes pitch
+    @durations.map do |dur|
+      if dur.negative?
+        Note.new(-dur)
+      else
+        Note.new(dur, pitch)
+      end
+    end
+  end
+end
+
+end
+
+class Array
+  def to_rhythm
+    Musicality::Rhythm.new(self)
+  end
+end

data/lib/musicality/composition/model/rhythm_class.rb

@@ -0,0 +1,30 @@
+module Musicality
+
+# A rhythm pattern based on an array of "portions". These portions encode an
+# array of fractions that sum to 1 (each portion would be numerator and the
+# sum of all portions would be the denominator). These fractions can be applied
+# to a total duration to form a rhythm (an array of durations).
+# @note Rests are represented by neagtive portions.
+class RhythmClass
+  attr_reader :portions_sum, :portions
+  def initialize portions
+    if portions.find {|x| x.zero? }
+      raise ArgumentError, "rhythm class contains portion(s) that are zero"
+    end
+    @portions = portions.clone.freeze
+    @portions_sum = @portions.inject(0) {|sum,x| sum + x.abs}
+  end
+
+  # Use the rhythm class to generate a rhtyhm
+  def to_rhythm(total_dur)
+    Rhythm.new @portions.map {|x| Rational(x,@portions_sum) * total_dur }
+  end
+end
+
+end
+
+class Array
+  def to_rhythm_class
+    Musicality::RhythmClass.new(self)
+  end
+end

data/lib/musicality/composition/sequencing/drum_machine/drum_kit.rb

@@ -0,0 +1,18 @@
+module Musicality
+
+# A collection of settings for performing drum parts
+class DrumKit
+  attr_reader :part_settings
+  def initialize part_settings
+    non_drumpart_names = part_settings.select do |part_name|
+      !DRUM_PARTS.include?(part_name)
+    end
+    if non_drumpart_names.any?
+      raise ArgumentError, "Part-names used that are not drum parts: #{non_drumpart_names.inspect}"
+    end
+
+    @part_settings = part_settings.freeze
+  end
+end
+
+end

data/lib/musicality/composition/sequencing/drum_machine/drum_machine.rb

@@ -0,0 +1,59 @@
+module Musicality
+
+class DrumMachine < Sequencer
+  def initialize drum_patterns
+    raise ArgumentError if drum_patterns.empty?
+
+    prev_durations = []
+    existing_part_notes = {}
+    drum_patterns.each do |drum_pattern|
+      durations = drum_pattern.part_notes.values.map do |notes|
+        notes.inject(0) {|sum, note| sum + note.duration }
+      end
+      if durations.uniq.size != 1
+        raise ArgumentError, "Drum pattern has part notes of differing total duration #{drum_pattern}"
+      end
+      duration = durations.first
+      if duration <= 0
+        raise ArgumentError, "Drum pattern has non-positive part notes"
+      end
+
+      drum_pattern.part_notes.each do |part_name, notes|
+        # Create part with rest notes from all the previous patterns durations
+        unless existing_part_notes.has_key?(part_name)
+          existing_part_notes[part_name] = prev_durations.map { |d| Note.new(d) }
+        end
+
+        existing_part_notes[part_name] += notes
+      end
+
+      # For parts that exist previously but not in the current drum pattern, add a rest note
+      existing_part_notes.each do |part_name, notes|
+        unless drum_pattern.part_notes.has_key?(part_name)
+          existing_part_notes[part_name].push Note.new(duration)
+        end
+      end
+
+      prev_durations.push duration
+    end
+
+    part_sequenceables = Hash[ existing_part_notes.map do |part_name, note_array|
+      [ part_name, NoteArray.new(note_array) ]
+    end]
+
+    super(part_sequenceables)
+  end
+
+  def make_empty_parts drum_kit, part_dynamics = {}
+    Hash[ part_names.map do |part_name|
+      unless drum_kit.part_settings.has_key?(part_name)
+        raise ArgumentError, "Drum kit does not have settings for part: #{part_name}"
+      end
+      part_dynamic = part_dynamics.has_key?(part_name) ? part_dynamics[part_name] : Dynamics::MF
+      part = Part.new(part_dynamic, settings: [drum_kit.part_settings[part_name]])
+      [ part_name, part ]
+    end]
+  end
+end
+
+end

data/lib/musicality/composition/sequencing/drum_machine/drum_parts.rb

@@ -0,0 +1,21 @@
+module Musicality
+
+module DrumParts
+  ACCENT = "AC"
+  CRASH_CYMBAL = "CCY"
+  RIDE_CYMBAL = "RCY"
+  CLOSED_HI_HAT = "CH"
+  OPEN_HI_HAT = "OH"
+  HI_TOM = "HT"
+  MED_TOM = "MT"
+  LOW_TOM = "LT"
+  SNARE_DRUM = "SD"
+  RIM_SHOT = "RS"
+  CLAPS = "CPS"
+  COW_BELL = "CB"
+  BASS_DRUM = "BD"
+end
+
+DRUM_PARTS = DrumParts.constants.map { |sym| DrumParts.const_get(sym) }
+
+end

data/lib/musicality/composition/sequencing/drum_machine/drum_pattern.rb

@@ -0,0 +1,66 @@
+module Musicality
+
+class DrumPattern
+  attr_reader :part_notes, :duration
+
+  DRUM_PART_PITCHES = {
+    DrumParts::BASS_DRUM => Pitches::G1,
+    DrumParts::SNARE_DRUM => Pitches::G3,
+    DrumParts::HI_TOM => Pitches::D3,
+    DrumParts::MED_TOM => Pitches::B2,
+    DrumParts::LOW_TOM => Pitches::G2,
+  }
+  DUMMY_PITCH = Pitches::C4
+
+  def initialize duration, part_portions
+    @duration = duration
+
+    non_drumpart_names = part_portions.select do |part_name|
+      !DRUM_PARTS.include?(part_name)
+    end
+    if non_drumpart_names.any?
+      raise ArgumentError, "Part names used that are not drum parts: #{non_drumpart_names.inspect}"
+    end
+
+    accent_offsets = if part_portions.has_key?(DrumParts::ACCENT)
+      DrumPattern.determine_accent_offsets(
+        part_portions.delete(DrumParts::ACCENT).to_rhythm_class.to_rhythm(duration))
+    else
+      []
+    end
+
+    @part_notes = Hash[ part_portions.map do |part_name, portions|
+      pitch = DRUM_PART_PITCHES[part_name] || DUMMY_PITCH
+      notes = portions.to_rhythm_class.to_rhythm(duration).to_notes(pitch)
+      DrumPattern.apply_accents(notes, accent_offsets)
+      [ part_name, notes ]
+    end ]
+  end
+
+  def self.determine_accent_offsets accent_rhythm
+    accent_offsets = []
+    cum_dur = 0
+
+    accent_rhythm.durations.each do |dur|
+      if dur > 0
+        accent_offsets.push cum_dur
+      end
+      cum_dur += dur
+    end
+
+    return accent_offsets
+  end
+
+  def self.apply_accents notes, accent_offsets
+    cum_dur = 0
+
+    notes.each do |note|
+      if note.pitches.any? && accent_offsets.include?(cum_dur)
+        note.mark_accented!
+      end
+      cum_dur += note.duration
+    end
+  end
+end
+
+end

data/lib/musicality/composition/sequencing/drum_machine/drum_patterns/pop_drum_patterns.rb

@@ -0,0 +1,146 @@
+module Musicality
+
+module DrumPatterns
+  POP_1 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1] * 8,
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,1,-1,1,-1,1,-1,1,1,1,-1,1,-1,1,-1,1]
+  )
+
+  POP_2 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1] * 8,
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,-2,1,1,1,1,-1,1,-2,1,1,1]
+  )
+
+  POP_3 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1,1,-1,1,-2,1,1,-1,1,-1,1,-2,1],
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,1,-1,1,-1,1,-2,1,1,-1,1,-4]
+  )
+
+  POP_4 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1] * 8,
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1]
+  )
+
+
+  POP_5 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1] * 8,
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,1,-1,1,-4,1,1,-1,1,-2,1,1]
+  )
+
+
+  POP_6 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1] * 8,
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,1,-1,1,-4,1,1,-1,1,-4]
+  )
+
+  POP_7 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1,1,-3,1,-1,1,-1,1,-3,1,-1],
+    DrumParts::OPEN_HI_HAT => [-4,1,-7,1,-3],
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,1,-2,1,-3,1,1,-2,1,-1]
+  )
+
+  POP_8 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-3,1,-3,1,-3,1,-3],
+    DrumParts::OPEN_HI_HAT => [-2,1,-3,1,-3,1,-3,1,-1],
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,-3,1,-3,1,-3,1,-1]
+  )
+
+  POP_9 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-6,1,-5,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1,-1,1,-1,1,-1,1,-1,1,-3,1,-3],
+    DrumParts::OPEN_HI_HAT => [-10,1,-3,1,-1],
+    DrumParts::SNARE_DRUM => [-6,1,-5,1,-1,1,-1],
+    DrumParts::BASS_DRUM => [1,-1,1,-7,1,-5]
+  )
+
+  POP_10 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [1]*12 + [-4],
+    DrumParts::OPEN_HI_HAT => [-13,1,-1,1],
+    DrumParts::SNARE_DRUM => [-4,1,-2,1,-4,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,-5,1,1,-1,1,-1,1,-1,1]
+  )
+
+  POP_11 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => [-1,1,1,1]*4,
+    DrumParts::SNARE_DRUM => [1,-3,1,-3,1,-3,1,-3],
+    DrumParts::BASS_DRUM => [-2,1,-2,1,-1,1,-2,1,-2,1,-1,1]
+  )
+
+  POP_12 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::CLOSED_HI_HAT => ([1]*4 + [-1,1,-1,1])*2,
+    DrumParts::OPEN_HI_HAT => [-6,1,-7,1,-1],
+    DrumParts::SNARE_DRUM => [-4,1,-7,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,-4,1,1,-1,1,-4,1]
+  )
+
+  POP_BREAK_1 = DrumPattern.new(1,
+    DrumParts::HI_TOM => [-8,1,1,-1,1,-4],
+    DrumParts::MED_TOM => [-4,1,-2,1,-8],
+    DrumParts::LOW_TOM => [-12,1,1,1,-1],
+    DrumParts::SNARE_DRUM => [1,1,1,1,-12],
+    DrumParts::BASS_DRUM => [1,1,-6,1,-7],
+  )
+
+  POP_BREAK_2 = DrumPattern.new(1,
+    DrumParts::ACCENT => [1,-2] * 5 + [-1],
+    DrumParts::HI_TOM => [-6,1,-9],
+    DrumParts::MED_TOM => [-3,1,-12],
+    DrumParts::LOW_TOM => [-9,1,-6],
+    DrumParts::SNARE_DRUM => [1,-11,1,-3],
+    DrumParts::BASS_DRUM => [-1,1,1] * 5 + [1],
+  )
+
+  POP_BREAK_3 = DrumPattern.new(1,
+    DrumParts::CRASH_CYMBAL => [1,-15],
+    DrumParts::HI_TOM => [-13,1,1,1],
+    DrumParts::MED_TOM => [-8,1,1,-1,1,-4],
+    DrumParts::SNARE_DRUM => [-2,1,-3,1,-9],
+    DrumParts::BASS_DRUM => [1,-7,1,-7],
+  )
+
+  POP_BREAK_4 = DrumPattern.new(1,
+    DrumParts::ACCENT => [-4,1,-7,1,-3],
+    DrumParts::SNARE_DRUM => [-4,1,-4,1,1,-1,1,-3],
+    DrumParts::BASS_DRUM => [1,-1,1,-2,1,-1,1,-3,1,-4],
+  )
+
+  POP_BREAK_5 = DrumPattern.new(1,
+    DrumParts::CRASH_CYMBAL => [-12,1,1,-2],
+    DrumParts::MED_TOM => [-3,1,-12],
+    DrumParts::LOW_TOM => [-6,1,-9],
+    DrumParts::SNARE_DRUM => [1,-8,1,-6],
+    DrumParts::BASS_DRUM => [-12,1,1,-2],
+  )
+
+  POP_BREAK_6 = DrumPattern.new(1,
+    DrumParts::ACCENT => [1,-2,1,1,-2,1,-6,1,-1],
+    DrumParts::CRASH_CYMBAL => [1,-15],
+    DrumParts::CLOSED_HI_HAT => [-7,1,-8],
+    DrumParts::OPEN_HI_HAT => [-13,1,-1],
+    DrumParts::MED_TOM => [-4,1,1,1,-9],
+    DrumParts::LOW_TOM => [-11,1,1,1,-1],
+    DrumParts::SNARE_DRUM => [-1,1,1,1,-5,1,1,-5],
+    DrumParts::BASS_DRUM => [1,-6,1,-8],
+  )
+end
+
+end

data/lib/musicality/composition/sequencing/note_array.rb

@@ -0,0 +1,33 @@
+module Musicality
+
+class NoteArray
+  include Sequenceable
+
+  attr_reader :duration, :notes
+  def initialize notes
+    raise ArgumentError if notes.empty?
+
+    @notes = notes.clone.freeze
+    @notes_idx = 0
+    @notes_count = notes.size
+
+    @duration = @notes.inject(0) {|sum, note| sum + note.duration}
+  end
+
+  def next_note
+    note = @notes[@notes_idx]
+
+    @notes_idx += 1
+    if @notes_idx >= @notes_count
+      @notes_idx = 0
+    end
+
+    return note
+  end
+
+  def reset
+    @notes_idx = 0
+  end
+end
+
+end

data/lib/musicality/composition/sequencing/note_fifo.rb

@@ -0,0 +1,73 @@
+module Musicality
+
+class NoteFIFO
+  attr_reader :notes, :duration
+  def initialize initial_notes = []
+    @notes = []
+    @duration = 0
+    add_notes(initial_notes) if initial_notes.any?
+  end
+
+  def empty?
+    @notes.empty?
+  end
+
+  def add_note note
+    if note.duration <= 0
+      raise ArgumentError, "note have non-positive duration: #{note}"
+    end
+    @notes.push note
+    @duration += note.duration
+  end
+
+  def add_notes notes
+    nonpositive = notes.select {|x| x.duration <= 0}
+    if nonpositive.any?
+      raise ArgumentError, "one or more notes have non-positive duration: #{notes}"
+    end
+    @notes += notes
+    @duration += notes.inject(0) {|sum, note| sum + note.duration }
+  end
+
+  # Return a sequence of notes with total duration equal to the given target duration, and remove
+  # the same notes from the accumulator. Any notes beyond the given target duration are left in
+  # the accumulator. Split a note into two tied notes if needed.
+  def remove_notes target_duration
+    raise ArgumentError, "negative target duration #{target_duration}" if target_duration < 0
+
+    if target_duration > duration
+      raise ArgumentError, "target duration #{target_duration} is greater than duration of accumulated notes #{duration}"
+    end
+
+    removed_notes = if target_duration == 0
+      []
+    elsif target_duration == duration
+      notes.shift(notes.size)
+    else
+      dur_so_far = 0.to_r
+      num_notes_taking = 0
+      @notes.each_with_index do |note, idx|
+        dur_so_far += note.duration
+        num_notes_taking += 1
+        break if dur_so_far >= target_duration
+      end
+
+      notes_taking = notes.shift(num_notes_taking)
+      excess_dur = dur_so_far - target_duration
+
+      if excess_dur > 0
+        @notes.unshift(notes_taking[-1].resize(excess_dur))
+        notes_taking[-1] = notes_taking[-1].resize(notes_taking[-1].duration - excess_dur)
+        notes_taking[-1].pitches.each do |pitch|
+          notes_taking[-1].links[pitch] = Link::Tie.new
+        end
+      end
+      notes_taking
+    end
+
+    @duration = @duration - target_duration
+    return removed_notes
+  end
+end
+
+end

data/lib/musicality/composition/sequencing/sequenceable.rb

@@ -0,0 +1,9 @@
+module Musicality
+
+# Requires instance methods:
+# * #next_note Produces note with each call
+# * #reset Reset back to the beginning of the note sequence
+module Sequenceable
+end
+
+end

data/lib/musicality/composition/sequencing/sequencer.rb

@@ -0,0 +1,35 @@
+module Musicality
+
+class Sequencer
+  attr_reader :part_names, :part_sequenceables
+
+  def initialize part_sequenceables
+    @part_sequenceables = part_sequenceables.freeze
+    @part_note_fifos = Hash[ part_sequenceables.keys.map {|partname| [ partname, NoteFIFO.new ] } ]
+    @part_names = @part_sequenceables.keys
+  end
+
+  def next_part_notes target_duration
+    if target_duration <= 0
+      raise ArgumentError, "Target duration #{target_duration} is non-positive}"
+    end
+    part_notes = {}
+
+    @part_sequenceables.each do |partname, sequenceable|
+      note_fifo = @part_note_fifos[partname]
+
+      while note_fifo.duration < target_duration
+        note_fifo.add_note(sequenceable.next_note)
+      end
+      part_notes[partname] = note_fifo.remove_notes(target_duration)
+    end
+
+    return part_notes
+  end
+
+  def reset
+    @part_sequenceables.values.each { |s| s.reset }
+  end
+end
+
+end

data/lib/musicality/errors.rb

@@ -10,5 +10,5 @@ module Musicality
   class DomainError < StandardError; end
   class EmptyError < StandardError; end
   class DurationMismatchError < StandardError; end
-
-end
+  class ParseError < StandardError; end
+end

data/lib/musicality/notation/model/dynamics.rb

@@ -1,7 +1,7 @@
 module Musicality
 module Dynamics
-  PPP = 0.05
-  FFF = 0.5
+  PPP = 0.1
+  FFF = 0.9
   DYNAMIC_RATIO = (FFF/PPP)**(1.0/7.0) # 7 ratios between the 8 dynamic levels
 
   PP = PPP*DYNAMIC_RATIO