musicality 0.2.0 → 0.3.0

data/lib/musicality/notation/util/function.rb

@@ -0,0 +1,99 @@
+module Musicality
+
+class Function
+  DOMAIN_MIN, DOMAIN_MAX = -Float::INFINITY, Float::INFINITY
+  
+  def sample xrange, srate
+    xrange.step(Rational(1,srate)).map { |x| at(x) }
+  end
+
+  # x  in start domain, transformed to x in end domain
+  def self.transform_domains start_domain, end_domain, x
+    perc = (x - start_domain.first) / (start_domain.last - start_domain.first).to_f
+    return perc * (end_domain.last - end_domain.first) + end_domain.first
+  end
+
+  class Constant < Function
+    attr_reader :value
+    
+    def initialize value
+      @value = value
+    end
+    
+    def at(x)
+      @value
+    end
+    
+    def ==(other)
+      super(other) && @value == other.value
+    end
+  end
+  
+  class Linear < Function
+    attr_reader :slope, :intercept
+    
+    def initialize p1,p2
+      @slope = (p2[1] - p1[1])/(p2[0] - p1[0]).to_f
+      @intercept = p1[1] - @slope * p1[0]
+    end
+    
+    def at(x)
+      x * @slope + @intercept
+    end
+    
+    def ==(other)
+      super(other) && @slope == other.slope && @intercept == other.intercept
+    end
+  end
+  
+  class Sigmoid < Function
+    def self.sigm x
+      1.0 / (1 + Math::exp(-x))
+    end
+    
+    #def self.inv_sigm y
+    #  -Math::log((1-y)/y.to_f)
+    #end
+    
+    SIGM_DOMAIN = -5..5
+    SIGM_RANGE = Sigmoid.sigm(SIGM_DOMAIN.first)..Sigmoid.sigm(SIGM_DOMAIN.last)
+    SIGM_SPAN = SIGM_RANGE.last - SIGM_RANGE.first
+    
+    attr_reader :y0, :dy, :domain
+    def initialize p0, p1
+      @y0, y1 = p0[1], p1[1]
+      @dy = y1 - @y0
+      @domain = p0[0]..p1[0]
+    end
+    
+    def at(x)
+      x_ = Function.transform_domains(@domain, SIGM_DOMAIN, x)
+      y_ = (Sigmoid.sigm(x_) - SIGM_RANGE.first) / SIGM_SPAN
+      y = @y0 + y_ * @dy
+      return y
+    end
+    
+    #def from(y)
+    #  y2 = (y - @y0) / @dy
+    #  x2 = Sigmoid.inv_sigm(y2 * SIGM_SPAN + SIGM_RANGE.first)
+    #  x = Function.transform_domains(SIGM_DOMAIN, @domain, x2)
+    #  return x
+    #end
+    
+    # Given a domain, an xy-point in that domain, and the y-value at
+    # the end of the domain, find the y-value at the start of the domain,
+    # assuming the the function is sigmoid.
+    def self.find_y0 domain, pt, y1
+      x,y = pt
+      x_ = Function.transform_domains(domain, SIGM_DOMAIN, x)
+      y_ = (sigm(x_) - SIGM_RANGE.first) / SIGM_SPAN
+      return Function::Linear.new([y_,y],[1,y1]).at(0)
+    end
+      
+    def ==(other)
+      super(other) && @y0 == other.y0 && @dy == other.dy
+    end
+  end  
+end
+
+end

data/lib/musicality/notation/util/piecewise_function.rb

@@ -1,121 +1,101 @@
 module Musicality
 
-# Combine functions that are each applicable for a non-overlapping domain.
-#
-# @author James Tunnell
-class PiecewiseFunction
-  attr_reader :pieces
-  
-  # Take an array of points (each point is a two-element array pair) and
-  # create a piecewise function to calculate values in-between.
-  def initialize points = []
-    @pieces = { }
+class Function
+  # Combine functions that are each applicable for a non-overlapping domain.
+  #
+  # @author James Tunnell
+  class Piecewise < Function
+    attr_reader :pieces
     
-    points = points.sort_by {|p| p[0]}
-    
-    if points.count > 1
-      if points.is_a?(Hash)
-        points = points.to_a
-      end
-      
-      for i in 1...points.count
-        add_points points[i-1], points[i]
-      end
+    # Take an array of points (each point is a two-element array pair) and
+    # create a piecewise function to calculate values in-between.
+    def initialize
+      @pieces = { }
     end
-  end
-  
-  def add_points prev_point, point
-    domain = prev_point[0]..point[0]
-    func = lambda do |x|
-      perc = (x - domain.min).to_f / (domain.max - domain.min)
-      y = Interpolation.linear prev_point[1], point[1], perc
-      return y
-    end
-    add_piece(domain, func)
-  end
-  
-  # Add a function piece, which covers the given domain (includes domain start 
-  # but not the end).
-  # @param [Range] domain The function domain. If this overlaps an existing domain,
-  #                       the existing domain will be split with the non-
-  #                       overlapping pieces kept and the overlapping old piece
-  #                       discarded.
-  def add_piece domain, func
     
-    raise ArgumentError, "domain is not a Range" if !domain.is_a? Range
-    raise ArgumentError, "func is not a Proc" if !func.is_a? Proc
+    def ==(other)
+      @pieces == other.pieces
+    end
     
-    contains_domain_completely = @pieces.select { |d,f| d.include?(domain.begin) && d.include?(domain.end) }
-    if contains_domain_completely.any?
-      contains_domain_completely.each do |d,f|
-        l = d.begin...domain.begin
-        if d.exclude_end?
-          r = domain.end...d.end
-        else
-          r = domain.end..d.end
+    # Add a function piece, which covers the given domain (includes domain start 
+    # but not the end).
+    # @param [Range] domain The function domain. If this overlaps an existing domain,
+    #                       the existing domain will be split with the non-
+    #                       overlapping pieces kept and the overlapping old piece
+    #                       discarded.
+    def add_piece domain, func
+      
+      raise ArgumentError, "domain is not a Range" unless domain.is_a? Range
+      raise ArgumentError, "func is not a Function" unless func.is_a? Function
+      
+      contains_domain_completely = @pieces.select { |d,f| d.include?(domain.begin) && d.include?(domain.end) }
+      if contains_domain_completely.any?
+        contains_domain_completely.each do |d,f|
+          l = d.begin...domain.begin
+          if d.exclude_end?
+            r = domain.end...d.end
+          else
+            r = domain.end..d.end
+          end
+          
+          @pieces.delete d
+          
+          if domain.begin != d.begin
+            @pieces[l] = f
+          end
+          if domain.end == d.end
+            @pieces[domain.begin..domain.end] = func
+          else
+            @pieces[domain.begin...domain.end] = func
+            @pieces[r] = f
+          end
+        end
+      else
+        delete_completely = @pieces.select { |d,f| domain.include?(d.begin) && domain.include?(d.end) }
+        delete_completely.each do |d,f|
+          @pieces.delete d
         end
         
-        @pieces.delete d
+        # should only be one
+        move_end = @pieces.select { |d,f| domain.include?(d.end) }
+        move_end.each do |d,f|
+          @pieces.delete d
+          @pieces[d.begin...domain.begin] = f
+        end
         
-        if domain.begin != d.begin
-          @pieces[l] = f
+        # should only be one
+        move_begin = @pieces.select { |d,f| domain.include?(d.begin) }
+        move_begin.each do |d,f|
+          @pieces.delete d
+          if d.exclude_end?
+            @pieces[domain.end...d.end] = f
+          else
+            @pieces[domain.end..d.end] = f
+          end
         end
-        if domain.end == d.end
-          @pieces[domain.begin..domain.end] = func
-        else
+        
+        if move_begin.any?
           @pieces[domain.begin...domain.end] = func
-          @pieces[r] = f
-        end
-      end
-    else
-      delete_completely = @pieces.select { |d,f| domain.include?(d.begin) && domain.include?(d.end) }
-      delete_completely.each do |d,f|
-        @pieces.delete d
-      end
-      
-      # should only be one
-      move_end = @pieces.select { |d,f| domain.include?(d.end) }
-      move_end.each do |d,f|
-        @pieces.delete d
-        @pieces[d.begin...domain.begin] = f
-      end
-      
-      # should only be one
-      move_begin = @pieces.select { |d,f| domain.include?(d.begin) }
-      move_begin.each do |d,f|
-        @pieces.delete d
-        if d.exclude_end?
-          @pieces[domain.end...d.end] = f
         else
-          @pieces[domain.end..d.end] = f
+          @pieces[domain] = func
         end
       end
-      
-      if move_begin.any?
-        @pieces[domain.begin...domain.end] = func
-      else
-        @pieces[domain] = func
-      end
     end
-  end
-  
-  # Evaluate the piecewise function by finding a function piece whose domain 
-  # includes the given independent value.
-  def eval x
-    y = nil
     
-    @pieces.each do |domain, func|
-      if domain.include? x
-        y = func.call x
-        break
-      end
+    def domain_include? x
+      !@pieces.keys.detect {|domain| domain.include?(x)}.nil?
     end
     
-    if y.nil?
-      raise ArgumentError, "The input #{x} is not in the domain."
+    # Evaluate the piecewise function by finding a function piece whose domain 
+    # includes the given independent value.
+    def at x
+      @pieces.each do |domain, func|
+        if domain.include? x
+          return func.at(x)
+        end
+      end
+      raise DomainError, "The input #{x} is not in the domain."
     end
-    
-    return y
   end
 end
 

data/lib/musicality/notation/util/transition.rb

@@ -0,0 +1,12 @@
+module Musicality
+
+class Transition < Function::Piecewise
+  def initialize func, transition_domain
+    super()
+    add_piece(transition_domain, func)
+    add_piece(transition_domain.last..DOMAIN_MAX,
+              Function::Constant.new(func.at(transition_domain.last)))
+  end
+end
+
+end

data/lib/musicality/notation/util/value_computer.rb

@@ -1,169 +1,29 @@
 module Musicality
 
 # Given a start value, and value changes, compute the value at any offset.
-class ValueComputer
+class ValueComputer < Function::Piecewise
   attr_reader :piecewise_function
-
   def initialize start_value, value_changes = {}
-    @piecewise_function = PiecewiseFunction.new
-    set_default_value start_value
-    
+    super()
+    set_default_value(start_value)
     if value_changes.any?
       value_changes.sort.each do |offset,change|
-        
-        case change
-        when Change::Immediate
-          add_immediate_change change, offset
-        when Change::Gradual
-          add_linear_change change, offset
-        #  add_sigmoid_change change, offset
-        end
-        
+        add_change(offset, change)
       end
     end
   end
-
-  # Compute the value at the given offset.
-  # @param [Numeric] offset The given offset to compute value at.
-  def value_at offset
-    @piecewise_function.eval offset
-  end
-  
-  def sample xmin, xmax, srate
-    sample_period = Rational(1,srate)
-    ((xmin.to_r)..(xmax.to_r)).step(sample_period).map do |x|
-      value_at(x)
-    end
-  end
-  
-  # finds the minimum domain value
-  def domain_min
-    -Float::INFINITY
-  end
-
-  # finds the maximum domain value
-  def domain_max
-    Float::INFINITY
-  end
-
-  # finds the minimum domain value
-  def self.domain_min
-    -Float::INFINITY
-  end
-
-  # finds the maximum domain value
-  def self.domain_max
-    Float::INFINITY
-  end
-
+    
   private
 
-  def set_default_value value
-    func = lambda {|x| value }
-    @piecewise_function.add_piece( domain_min..domain_max, func )
+  def add_change offset, change
+    start_value = at(offset)
+    trans = change.to_transition(offset, start_value)
+    add_piece(offset..Function::DOMAIN_MAX, trans)
   end
   
-  # Add a function piece to the piecewise function, which will to compute value
-  # for a matching note offset. Transition duration will be ignored since the
-  # change is immediate.
-  #
-  # @param [ValueChange] value_change An event with information about the new value.
-  # @param [Numeric] offset
-  def add_immediate_change value_change, offset
-    func = nil
-    value = value_change.value
-    domain = offset..domain_max
-    func = lambda {|x| value }
-    
-    @piecewise_function.add_piece domain, func
-  end
-    
-  # Add a function piece to the piecewise function, which will to compute value
-  # for a matching note offset. If the dynamic event duration is non-zero, a 
-  # linear transition function is created.
-  #
-  # @param [ValueChange] value_change An event with information about the new value.
-  # @param [Numeric] offset
-  def add_linear_change value_change, offset
-    
-    func = nil
-    value = value_change.value
-    duration = value_change.duration
-    domain = offset..domain_max
-    
-    if duration == 0
-      add_immediate_change(value_change, offset)
-    else
-      b = @piecewise_function.eval domain.first
-      m = (value.to_f - b.to_f) / duration.to_f
-      
-      func = lambda do |x|
-        raise RangeError, "#{x} is not in the domain" if !domain.include?(x)
-        
-        if x < (domain.first + duration)
-          (m * (x - domain.first)) + b
-        else
-          value
-        end
-      end
-      @piecewise_function.add_piece domain, func
-    end
-  end
-
-  # Add a function piece to the piecewise function, which will to compute value
-  # for a matching note offset. If the dynamic event duration is non-zero, a 
-  # linear transition function is created.
-  #
-  # @param [ValueChange] value_change An event with information about the new value.
-  # @param [Numeric] offset
-  def add_sigmoid_change value_change, offset
-    
-    func = nil
-    start_value = @piecewise_function.eval offset
-    end_value = value_change.value
-    value_diff = end_value - start_value
-    duration = value_change.duration
-    domain = offset.to_f..domain_max
-    abruptness = 0.7 # value_change.transition.abruptness.to_f
-
-    if duration == 0
-      add_immediate_change(value_change,offset)
-    else
-      raise ArgumentError, "abruptness is not between 0 and 1" unless abruptness.between?(0,1)
-      
-      min_magn = 2
-      max_magn = 6
-      tanh_domain_magn = abruptness * (max_magn - min_magn) + min_magn
-      tanh_domain = -tanh_domain_magn..tanh_domain_magn
-
-      tanh_range = Math::tanh(tanh_domain.first)..Math::tanh(tanh_domain.last)
-      tanh_span = tanh_range.last - tanh_range.first
-
-      func = lambda do |x|
-        raise RangeError, "#{x} is not in the domain" if !domain.include?(x)
-          if x < (domain.first + duration)
-            start_domain = domain.first...(domain.first + duration)
-            x2 = transform_domains(start_domain, tanh_domain, x)
-            y = Math::tanh x2
-            z = (y / tanh_span) + 0.5 # ranges from 0 to 1
-            start_value + (z * value_diff)
-          else
-            end_value
-          end
-      end
-      @piecewise_function.add_piece domain, func
-    end
-  end
-
-  # x should be in the start domain 
-  def transform_domains start_domain, end_domain, x
-    perc = (x - start_domain.first) / (start_domain.last - start_domain.first).to_f
-    x2 = perc * (end_domain.last - end_domain.first) + end_domain.first
-  end
-
-  # 0 to 1
-  def logistic x
-    1.0 / (1 + Math::exp(-x))
+  def set_default_value value
+    func = Function::Constant.new(value)
+    add_piece(Function::DOMAIN_MIN..Function::DOMAIN_MAX, func)
   end
 end
 

data/lib/musicality/performance/conversion/score_collator.rb

@@ -48,30 +48,45 @@ class ScoreCollator
       seg = seg.first...seg.last
       
       # add segment start value
-      value = comp.value_at seg.first
+      value = comp.at seg.first
       new_changes[segment_start_offset] = Change::Immediate.new(value)
       
-      # add any immediate changes in segment
-      changes.select {|o,c| c.is_a?(Change::Immediate) && seg.include?(o) }.each do |off,c|
-	new_changes[(off - seg.first) + segment_start_offset] = c.clone
-      end
-      
-      # add gradual changes
-      changes.select {|o,c| c.is_a?(Change::Gradual)}.each do |off, change|
+      changes.each do |off,change|
 	adj_start_off = (off - seg.first) + segment_start_offset
-	end_off = off + change.duration
-	if seg.include?(off) # change that are wholly included in segment
-	  if end_off <= seg.last
-	    new_changes[adj_start_off] = change.clone
-	  else # change that overlap segment end
-	    over = end_off - seg.last
-	    new_changes[adj_start_off] = Change::Gradual.new(change.value,
-	      change.duration - over, change.elapsed, change.remaining + over)
+	
+	new_change = case change
+	when Change::Immediate
+	  change.clone if seg.include?(off)
+	when Change::Gradual::Trimmed
+	  end_off = off + change.remaining
+	  if off < seg.last && end_off > seg.first
+	    add_preceding = seg.first > off ? seg.first - off : 0
+	    add_trailing = end_off > seg.last ? end_off - seg.last : 0
+
+	    if add_preceding == 0 && add_trailing == 0
+	      change.clone
+	    else
+	      adj_start_off += add_preceding
+	      change.untrim.trim(change.preceding + add_preceding,
+				 change.trailing + add_trailing)
+	    end
 	  end
-	elsif end_off > seg.first && end_off < seg.last # change that overlap segment start
-	  under = seg.first - off
-	  new_changes[segment_start_offset] = Change::Gradual.new(change.value,
-	    change.duration - under, change.elapsed + under, change.remaining)
+	when Change::Gradual
+	  end_off = off + change.duration
+	  if off < seg.last && end_off > seg.first
+	    preceding = seg.first > off ? seg.first - off : 0
+	    trailing = end_off > seg.last ? end_off - seg.last : 0
+	    if preceding == 0 && trailing == 0
+	      change.clone
+	    else
+	      adj_start_off += preceding
+	      change.trim(preceding, trailing)
+	    end
+	  end
+	end
+	
+	unless new_change.nil?
+	  new_changes[adj_start_off] = new_change
 	end
       end
     end

data/lib/musicality/performance/midi/part_sequencer.rb

@@ -81,12 +81,9 @@ class PartSequencer
     dyn_comp = ValueComputer.new(start_dyn,dyn_changes)
     finish = 0
     if dyn_changes.any?
-      finish, change = dyn_changes.max
-      if change.is_a? Change::Gradual
-        finish += change.duration
-      end
+      finish = dyn_changes.map {|off,ch| ch.offsets(off).max }.max
     end
-    samples = dyn_comp.sample(0, finish, sample_rate)
+    samples = dyn_comp.sample(0..finish, sample_rate)
     
     prev = nil
     samples.each_index do |i|

data/lib/musicality/validatable.rb

@@ -1,7 +1,12 @@
 # assumes that @checks is defined as an array of no-arg lambdas, each
 # lambda raising an error (with useful msg) when check fails
 module Validatable
-  attr_reader :errors
+  def errors
+    if @errors.nil?
+      self.validate
+    end
+    return @errors
+  end
   
   def check_methods; []; end
   def validatables; []; end

data/lib/musicality/version.rb

@@ -1,3 +1,3 @@
 module Musicality
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/musicality.rb

@@ -47,17 +47,17 @@ require 'musicality/notation/packing/program_packing'
 require 'musicality/notation/packing/score_packing'
 
 require 'musicality/notation/util/interpolation'
+require 'musicality/notation/util/function'
 require 'musicality/notation/util/piecewise_function'
+require 'musicality/notation/util/transition'
 require 'musicality/notation/util/value_computer'
 
 require 'musicality/notation/conversion/tempo_conversion'
 require 'musicality/notation/conversion/change_conversion'
 require 'musicality/notation/conversion/note_time_converter'
-require 'musicality/notation/conversion/unmeasured_score_converter'
-require 'musicality/notation/conversion/unmeasured_score_conversion'
 require 'musicality/notation/conversion/measure_note_map'
-require 'musicality/notation/conversion/measured_score_converter'
-require 'musicality/notation/conversion/measured_score_conversion'
+require 'musicality/notation/conversion/score_converter'
+require 'musicality/notation/conversion/score_conversion'
 
 #
 # Performance

data/musicality.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 2.9"
+  spec.add_development_dependency "pry"
   
   spec.add_dependency "treetop", "~> 1.5"
   spec.add_dependency 'midilib', '~> 2.0'