musicality 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9413fe250183b04ea15a863a580cd90887ccb5e
-  data.tar.gz: d2820bd7695d490fb139508d663b202b2d867202
+  metadata.gz: 1f460185c537892ef1e12ffce5b1c829095666c7
+  data.tar.gz: fc1512fe588da6ee7599aea61ba713d268c50cc3
 SHA512:
-  metadata.gz: ffb85df1738b9948c0d23c627be1a42b195ce438b9098575ec9d662b1383f9689b7c9bc57cd432498bd9dd87306d4ddb5f8c4ad481502c3d3d1dfa664fe7bfca
-  data.tar.gz: f4e9a0f14009a2a50b3cf377504283cca9e5858bce3335649a80bb99021f386ed6203b62f88ea935541976bddfedb81bf766f5ffb8648ca9e1b1fe67f3236eeb
+  metadata.gz: ab8468ae5d3f4daf66a6f054480969c0d81e5b409b9a52efc513b3fc8ec6ccf5cdace8be25df378d63a9002ec6c6db61afb9fe6d92506b01a3c53412f8abe587
+  data.tar.gz: 784d01d623fd8436e635853340905ab381915138d9ccf2773e3728084c0ad04b6083e16ee692546a7fd9556930eced67bd70e3703fad91abb3b427443a72695d

data/ChangeLog.md

@@ -0,0 +1,30 @@
+### 0.3.0 / 2014-11-24
+* Conversion of both tempo-based scores (measured and unmeasured) directly to time-based score
+* Trimming of gradual changes, useful in collating scores
+* Refactoring of ValueComputer using Function and Transition utility classes
+* Add optional start_value for gradual changes, for making them absolute (by default they're relative) 
+* Add 'with' kw arg to change pack/unpack methods, for converting start/end values
+
+### 0.2.0 / 2014-11-24
+
+* Add #seconds_long for timed score, #notes_long for tempo-based scores, and #measures_long for measure-based score
+
+### 0.1.0 / 2014-11-23
+
+* Pitch class that includes octave, semitone, and cent values
+* Note class that includes duration, pitches, articulation, accent, and links
+* Part class that includes notes and dynamics
+* Program class to define which sections are played, and in what order
+* Score classes, all of which include parts and a program, but more specifically:
+ * Measured score that also includes tempo and meter changes. It has measure-based program and changes, and note-based notes
+ * Unmeasured score that also includes tempo changes. It has note-based program, changes, notes
+ * Timed score which is entirely time-based
+* Pass block to help initialize a score or a part
+* Validation of core model classes (score, part, program, note, etc.), with error list
+* Based on Ruby 2.0
+* Stringizing and parsing methods for duration, pitch, note, and meter
+* Stringized notes include shorthand for note links and articulation
+* Packing/unpacking to/from hash, using stringizing/parsing to condense, esp. for notes
+* Convert score to MIDI file via midilib gem
+* bin/midify command-line utility to run MIDI conversion on score YAML file
+

data/lib/musicality/errors.rb

@@ -6,4 +6,5 @@ module Musicality
   class NonRationalError < StandardError; end
   class NonIncreasingError < StandardError; end
   class NotValidError < StandardError; end
+  class DomainError < StandardError; end
 end

data/lib/musicality/notation/conversion/change_conversion.rb

@@ -5,13 +5,73 @@ class Change
     def offsets base_offset
       [ base_offset ]
     end
+    
+    def remap base_offset, map
+      self.clone
+    end
+    
+    def to_transition offset, value
+      Transition::new(Function::Constant.new(@end_value), offset..offset)
+    end
   end
   
   class Gradual < Change
     def offsets base_offset
-      initial = base_offset - @elapsed
-      final = initial + @total_duration
-      [ initial, base_offset, base_offset + @impending, final ]
+      [ base_offset, base_offset + @duration ]
+    end
+    
+    def remap base_offset, map
+      newdur = map[base_offset + @duration] - map[base_offset]
+      Gradual.new(@end_value, newdur, @transition)
+    end
+    
+    def to_transition offset, value
+      p1 = [ offset, @start_value || value ]
+      p2 = [ offset + @duration, @end_value ]
+      func = case @transition
+      when LINEAR then Function::Linear.new(p1, p2)
+      when SIGMOID then Function::Sigmoid.new(p1, p2)
+      end
+      Transition.new(func, p1[0]..p2[0])
+    end
+    
+    class Trimmed < Gradual
+      def offsets base_offset
+        origin = base_offset - @preceding
+        [ origin, base_offset, base_offset + @remaining, origin + @duration ]
+      end
+      
+      def remap base_offset, map
+        x0 = base_offset - @preceding
+        y0 = map[x0]
+        new_dur = map[x0 + @duration] - y0
+        x1 = base_offset
+        y1 = map[x1]
+        Trimmed.new(@end_value, new_dur, @transition, preceding: y1 - y0,
+                    remaining: map[x1 + @remaining] - y1)
+      end
+      
+      def to_transition offset, value
+        x1,x2,x3 = offset - @preceding, offset, offset + @remaining
+        x4 = x1 + @duration
+        func = case @transition
+        when LINEAR
+          Function::Linear.new(@start_value.nil? ? [x2,value] : [x1,@start_value],[x4, @end_value])
+        when SIGMOID
+          y1 = @start_value || Function::Sigmoid.find_y0(x1..x4, [x2, value], @end_value)
+          Function::Sigmoid.new([x1,y1],[x4, @end_value])
+        end
+        Transition.new(func, x2..x3)
+      end
+      
+      private
+      
+      def inv_sigm start_domain, x
+        sigm_domain = Function::Sigmoid::SIGM_DOMAIN
+        x_ = Function.transform_domains(start_domain, sigm_domain, x)
+        dy = Function::Sigmoid::sigm(sigm_domain.last) - Function::Sigmoid::sigm(sigm_domain.first)
+        (Function::Sigmoid::sigm(x_) - Function::Sigmoid::sigm(sigm_domain.first)) / dy
+      end
     end
   end
 end

data/lib/musicality/notation/conversion/note_time_converter.rb

@@ -1,18 +1,36 @@
 module Musicality
-  
+
 # Convert offsets in unmeasured note time to just plain time. 
 class NoteTimeConverter
   # @param [ValueComputer] tempo_computer Given an offset, returns tempo
   # value in quarter-notes-per-minute
   # @param [Numeric] sample_rate Rate at which tempo values are sampled
   # in the conversion (samples/sec).
-  def initialize tempo_computer, sample_rate
-    @tempo_computer = tempo_computer
+  def initialize sample_rate
     @sample_period = Rational(1,sample_rate)
   end
+
+  class Unmeasured < NoteTimeConverter
+    def initialize tempo_computer, sample_rate
+      @tempo_computer = tempo_computer
+      super(sample_rate)
+    end
+
+    def notes_per_second_at offset
+      Tempo::QNPM.to_nps(@tempo_computer.at offset)
+    end
+  end
   
-  def notes_per_second_at offset
-    Tempo::QNPM.to_nps(@tempo_computer.value_at offset)
+  class Measured < NoteTimeConverter
+    def initialize tempo_computer, bdur_computer, sample_rate
+      @tempo_computer = tempo_computer
+      @bdur_computer = bdur_computer
+      super(sample_rate)
+    end
+
+    def notes_per_second_at offset
+      Tempo::BPM.to_nps(@tempo_computer.at(offset), @bdur_computer.at(offset))
+    end
   end
   
   # Calculate the time elapsed between given start/end note offset. Using the

data/lib/musicality/notation/conversion/score_conversion.rb

@@ -0,0 +1,60 @@
+module Musicality
+
+class Score
+  class Unmeasured < TempoBased
+    # Convert to timed score by converting measure-based offsets and note-based
+    # durations to time-based. This eliminates the use of tempos.
+    def to_timed tempo_sample_rate
+      ScoreConverter::Unmeasured.new(self, tempo_sample_rate).convert_score
+    end      
+  end
+  
+  class Measured < TempoBased
+    # Convert to timed score by converting measure-based offsets and note-based
+    # durations to time-based. This eliminates the use of meters and tempos.
+    def to_timed tempo_sample_rate
+      ScoreConverter::Measured.new(self, tempo_sample_rate).convert_score
+    end
+    
+    def measure_note_map
+      Conversion::measure_note_map(measure_offsets,measure_durations)
+    end
+
+    def measure_offsets
+      moffs = Set.new([0.to_r])
+      @tempo_changes.each {|moff,change| moffs += change.offsets(moff) }
+      @meter_changes.keys.each {|moff| moffs.add(moff) }
+      @parts.values.each do |part|
+        part.dynamic_changes.each {|moff,change| moffs += change.offsets(moff) }
+      end
+      moffs += @program.segments.map {|seg| [seg.first, seg.last] }.flatten
+      return moffs.sort
+    end
+  
+    def beat_durations
+      bdurs = @meter_changes.map do |offset,change|
+        [ offset, change.end_value.beat_duration ]
+      end.sort
+      
+      if bdurs.empty? || bdurs[0][0] != 0
+        bdurs.unshift([0.to_r,@start_meter.beat_duration])
+      end
+    
+      return Hash[ bdurs ]
+    end
+    
+    def measure_durations
+      mdurs = @meter_changes.map do |offset,change|
+        [ offset, change.end_value.measure_duration ]
+      end.sort
+      
+      if mdurs.empty? || mdurs[0][0] != 0
+        mdurs.unshift([0.to_r,@start_meter.measure_duration])
+      end
+    
+      return Hash[ mdurs ]
+    end  
+  end
+end
+
+end

data/lib/musicality/notation/conversion/score_converter.rb

@@ -0,0 +1,105 @@
+module Musicality
+
+class ScoreConverter
+  def self.convert_changes changes, offset_map
+    Hash[ changes.map do |off,change|
+      [ offset_map[off], change.remap(off,offset_map) ]
+    end ]    
+  end
+  
+  def self.convert_parts parts, offset_map
+    Hash[ parts.map do |name,part|
+      offset = 0.to_r
+      new_notes = part.notes.map do |note|
+        starttime = offset_map[offset]
+        endtime = offset_map[offset + note.duration]
+        offset += note.duration
+        newnote = note.clone
+        newnote.duration = endtime - starttime
+        newnote
+      end
+      new_dcs = convert_changes(part.dynamic_changes, offset_map)
+      [name, Part.new(part.start_dynamic,
+        notes: new_notes, dynamic_changes: new_dcs)]
+    end]
+  end
+  
+  def self.convert_program program, offset_map
+    Program.new(program.segments.map do |segment|
+      offset_map[segment.first]...offset_map[segment.last]
+    end)
+  end
+  
+  class TempoBased
+    def initialize parts, program, note_time_converter
+      @parts = parts
+      @program = program
+      @note_time_map = note_time_converter.note_time_map(note_offsets)
+    end
+    
+    def note_offsets
+      noffs = Set.new([0.to_r])
+      @parts.values.each do |part|
+        noff = 0.to_r
+        part.notes.each {|note| noffs.add(noff += note.duration) }
+        part.dynamic_changes.each {|noff2,change| noffs += change.offsets(noff2) }
+      end
+      noffs += @program.segments.map {|seg| [seg.first, seg.last] }.flatten
+      return noffs.sort
+    end
+
+    def convert_score
+      Score::Timed.new(parts: convert_parts, program: convert_program)
+    end
+  
+    # Convert note-based offsets & durations to time-based.
+    def convert_parts
+      ScoreConverter.convert_parts(@parts, @note_time_map)
+    end
+    
+    # Convert note-based offsets & durations to time-based.
+    def convert_program
+      ScoreConverter.convert_program(@program, @note_time_map)
+    end
+  end
+  
+  # Converts unmeasured score to timed score, by converting note-based offsets
+  # and durations to time-based, and eliminating the use of tempo.
+  class Unmeasured < TempoBased
+    def initialize score, tempo_sample_rate
+      if score.invalid?
+        raise NotValidError, "Errors detected given score: #{score.errors}"
+      end
+      tempo_computer = ValueComputer.new(score.start_tempo, score.tempo_changes)
+      ntc = NoteTimeConverter::Unmeasured.new(tempo_computer, tempo_sample_rate)
+      super(score.parts, score.program, ntc)
+    end
+  end
+  
+  # Converts measured score to timed score, by converting note-based offsets
+  # and durations to time-based, and eliminating the use of tempo and meters.
+  class Measured < TempoBased
+    def initialize score, tempo_sample_rate
+      if score.invalid?
+        raise NotValidError, "Errors detected given score: #{score.errors}"
+      end
+      mn_map = score.measure_note_map
+      new_parts = Hash[ score.parts.map do |name,part|
+        new_dcs = ScoreConverter.convert_changes(part.dynamic_changes, mn_map)
+        new_notes = part.notes.map {|n| n.clone } # note duration is already note-based
+        [name, Part.new(part.start_dynamic, notes: new_notes, dynamic_changes: new_dcs)]
+      end]      
+      new_program = ScoreConverter.convert_program(score.program, mn_map)
+      new_tempo_changes = ScoreConverter.convert_changes(score.tempo_changes, mn_map)
+      new_beat_durations = Hash[ score.beat_durations.map do |moff,bdur|
+        [mn_map[moff], Change::Immediate.new(bdur) ]
+      end]
+      tempo_computer = ValueComputer.new(score.start_tempo, new_tempo_changes)
+      bdur_computer = ValueComputer.new(score.start_meter.beat_duration, new_beat_durations)
+      ntc = NoteTimeConverter::Measured.new(tempo_computer, bdur_computer, tempo_sample_rate)
+      super(new_parts, new_program, ntc)
+    end
+  end
+end
+
+end

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

@@ -1,60 +1,130 @@
 module Musicality
 
 class Change
-  attr_reader :value, :duration
+  attr_reader :end_value
   
-  def initialize value, duration
-    @value = value
-    @duration = duration
+  def initialize end_value
+    @end_value = end_value
   end
   
   def ==(other)
     self.class == other.class &&
-    self.value == other.value &&
-    self.duration == other.duration
+    self.end_value == other.end_value
   end
-
+  
   class Immediate < Change
     def initialize value
-      super(value,0)
+      super(value)
     end
     
     def clone
-      Immediate.new(@value)
+      Immediate.new(@end_value)
     end
+    
+    def duration; 0; end
   end
   
   class Gradual < Change
-    attr_reader :elapsed, :impending, :remaining, :total_duration
+    LINEAR = :linear
+    SIGMOID = :sigmoid
+    TRANSITIONS = [LINEAR,SIGMOID]
+    
+    def self.linear end_value, duration, start_value: nil
+      Gradual.new(end_value, duration, LINEAR, start_value: start_value)
+    end
+
+    def self.sigmoid end_value, duration, start_value: nil
+      Gradual.new(end_value, duration, SIGMOID, start_value: start_value)
+    end
     
-    def initialize value, impending, elapsed=0, remaining=0
-      if elapsed < 0
-        raise NegativeError, "elapsed (#{elapsed}) is < 0"
+    attr_reader :duration, :transition, :start_value
+    def initialize end_value, duration, transition, start_value: nil
+      if duration <= 0
+        raise NonPositiveError, "duration (#{duration}) is <= 0"
+      end
+      
+      unless TRANSITIONS.include?(transition)
+        raise ArgumentError, "transition (#{transition}) is not supported"
       end
       
-      if impending <= 0
-        raise NonPositiveError, "impending (#{impending}) is <= 0"
+      @duration = duration
+      @transition = transition
+      @start_value = start_value
+      super(end_value)
+    end
+    
+    def ==(other)
+      super(other) && @duration == other.duration &&
+      @transition == other.transition &&
+      @start_value == other.start_value
+    end
+    
+    def clone; Gradual.new(@end_value, @duration, @transition); end
+    def relative?; @start_value.nil?; end
+    def absolute?; !@start_value.nil?; end
+    
+    class Trimmed < Gradual
+      attr_reader :preceding, :remaining
+      
+      def self.linear end_value, duration, start_value: nil, preceding: 0, remaining: 0
+        Trimmed.new(end_value, duration, LINEAR, start_value: start_value,
+                    preceding: preceding, remaining: remaining)
       end
       
-      if remaining < 0
-        raise NegativeError, "remaining #{remaining} is < 0"
+      def self.sigmoid end_value, duration, start_value: nil, preceding: 0, remaining: 0
+        Trimmed.new(end_value, duration, SIGMOID, start_value: start_value,
+                    preceding: preceding, remaining: remaining)
       end
       
-      @total_duration = elapsed + impending + remaining
-      @elapsed = elapsed
-      @impending = impending
-      @remaining = remaining
-      super(value,impending)
+      def initialize end_value, duration, transition, start_value: nil, preceding: 0, remaining: 0
+        if preceding < 0
+          raise NegativeError, "preceding (#{preceding}) is < 0"
+        end
+        
+        if remaining <= 0
+          raise NonPositiveError, "remaining (#{remaining}) is <= 0"
+        end
+        
+        @preceding, @remaining = preceding, remaining
+        super(end_value, duration, transition, start_value: start_value)
+      end
+      
+      def trailing
+        @duration - @preceding - @remaining
+      end
+      
+      def untrim
+        Gradual.new(@end_value, @duration, @transition, start_value: @start_value)
+      end
+      
+      def ==(other)
+        super(other) && @preceding == other.preceding && @remaining == other.remaining
+      end
+    
+      def clone
+        Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
+                    preceding: @preceding, remaining: @remaining)
+      end
     end
     
-    def ==(other)
-      super(other) &&
-      @elapsed == other.elapsed &&
-      @remaining == other.remaining
+    def trim_left(amount)
+      Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
+                  preceding: amount, remaining: (@duration - amount))
     end
     
-    def clone
-      Gradual.new(@value, @impending, @elapsed, @remaining)
+    def trim_right(amount)
+      Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
+                  preceding: 0, remaining: (@duration - amount))
+    end
+    
+    def trim(ltrim, rtrim)
+      Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
+                  preceding: ltrim, remaining: (@duration - ltrim - rtrim))
+    end
+    
+    def to_trimmed(preceding, remaining)
+      Trimmed.new(@end_value, @duration, @transition, start_value: @start_value,
+                  preceding: preceding, remaining: remaining)
     end
   end
 end

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

@@ -44,7 +44,7 @@ class Part
   end
   
   def ensure_dynamic_change_values_range
-    outofrange = @dynamic_changes.values.select {|v| !v.value.between?(0,1) }
+    outofrange = @dynamic_changes.values.select {|v| !v.end_value.between?(0,1) }
     if outofrange.any?
       raise RangeError, "dynamic change values #{outofrange} are not between 0 and 1"
     end

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

@@ -67,7 +67,7 @@ class Score
     end
     
     def check_tempo_changes
-      badvalues = @tempo_changes.select {|k,v| v.value <= 0 }
+      badvalues = @tempo_changes.select {|k,v| v.end_value <= 0 }
       if badvalues.any?
         raise NonPositiveError, "tempo changes (#{badvalues}) are not positive"
       end    
@@ -99,7 +99,7 @@ class Score
     end
     
     def validatables
-      super() + [ @start_meter ] + @meter_changes.values.map {|v| v.value}
+      super() + [ @start_meter ] + @meter_changes.values.map {|v| v.end_value}
     end
     
     def check_startmeter_type
@@ -109,7 +109,7 @@ class Score
     end
     
     def check_meterchange_types
-      badtypes = @meter_changes.select {|k,v| !v.value.is_a?(Meter) }
+      badtypes = @meter_changes.select {|k,v| !v.end_value.is_a?(Meter) }
       if badtypes.any?
         raise TypeError, "meter change values #{nonmeter_values} are not Meter objects"
       end
@@ -140,7 +140,7 @@ class Score
       moff_prev, mdur_prev = 0.to_r, @start_meter.measure_duration
       
       @meter_changes.sort.each do |moff,change|
-        mdur = change.value.measure_duration
+        mdur = change.end_value.measure_duration
         notes_elapsed = mdur_prev * (moff - moff_prev)
         noff = noff_prev + notes_elapsed
         

data/lib/musicality/notation/packing/change_packing.rb

@@ -2,45 +2,55 @@ module Musicality
 
 class Change
   class Immediate < Change
-    def pack
-      pack_common
+    def change_type_str; "Immediate"; end
+    def pack with: nil
+      super(:with => with)
     end
     
-    def self.unpack packing
-      new(packing["value"])
+    def self.unpack(packing, with: nil)
+      end_val = packing["end_value"]
+      new(with.nil? ? end_val : end_val.send(with))
     end
   end
   
   class Gradual < Change
-    def pack
-      packing = pack_common.merge("impending" => @impending)
-      unless @remaining == 0
-        packing["remaining"] = @remaining
-      end
-      unless @elapsed == 0
-        packing["elapsed"] = @elapsed
+    def change_type_str; "Gradual"; end
+    def pack with: nil
+      packing = super(:with => with)
+      packing.merge!("duration" => @duration, "transition" => @transition)
+      unless @start_value.nil?
+        packing["start_value"] = with.nil? ? @start_value : @start_value.send(with)
       end
       return packing
     end
+    def self.unpack packing, with: nil
+      start_val, end_val = packing["start_value"], packing["end_value"]
+      new(with.nil? ? end_val : end_val.send(with),
+          packing["duration"], packing["transition"],
+          start_value: (start_val.nil? || with.nil?) ? start_val : start_val.send(with))
+    end
     
-    def self.unpack packing
-      elapsed = packing["elapsed"] || 0
-      remaining = packing["remaining"] || 0
-      new(packing["value"], packing["impending"], elapsed, remaining)
+    class Trimmed < Gradual
+      def change_type_str; "Gradual::Trimmed"; end
+      def pack with: nil
+        super(:with => with).merge("preceding" => @preceding, "remaining" => @remaining)
+      end
+      def self.unpack packing, with: nil
+        Gradual.unpack(packing, :with => with).to_trimmed(
+          packing["preceding"], packing["remaining"])
+      end
     end
   end
 
-  def self.unpack packing
-    type = const_get(packing["type"])
-    type.unpack(packing)
-  end
-  
-  private
-  
-  def pack_common
-    { "type" => self.class.to_s.split("::")[-1],
-      "value" => @value }
+  def pack with: nil
+    { "end_value" => (with.nil? ? @end_value : @end_value.send(with)),
+      "type" => self.change_type_str }
   end
+
+  def self.unpack packing, with: nil
+    type = const_get(packing["type"])
+    type.unpack(packing, with: with)
+  end  
 end
 
 end

data/lib/musicality/notation/packing/score_packing.rb

@@ -53,7 +53,7 @@ class Score
     def pack
       return super().merge("start_meter" => start_meter.to_s,
         "meter_changes" => Hash[ meter_changes.map do |off,change|
-          [off,change.pack.merge("value" => change.value.to_s)]
+          [off,change.pack(:with => :to_s)]
         end ]
       )
     end
@@ -62,7 +62,7 @@ class Score
       score = superclass.unpack(packing)
       unpacked_start_meter = Meter.parse(packing["start_meter"])
       unpacked_mcs = Hash[ packing["meter_changes"].map do |off,p|
-        [off, Change.unpack(p.merge("value" => Meter.parse(p["value"]))) ]
+         [off, Change.unpack(p, :with => :to_meter) ]
       end ]
       
       new(unpacked_start_meter, score.start_tempo,