musicality 0.2.0 → 0.3.0

data/spec/notation/packing/change_packing_spec.rb

@@ -11,90 +11,154 @@ describe Change::Immediate do
       @p.should be_a Hash
     end
     
-    it 'should have "type" and "value" keys' do
+    it 'should have "type" and "end_value" keys' do
       @p.should have_key("type")
-      @p.should have_key("value")
+      @p.should have_key("end_value")
     end
     
     it 'should assign "Immediate" to "type" key' do
       @p["type"].should eq("Immediate")
     end
     
-    it 'should assign value to "value" key' do
-      @p["value"].should eq(@c.value)
+    it 'should assign end_value to "end_value" key' do
+      @p["end_value"].should eq(@c.end_value)
+    end
+    
+    context 'given :with method' do
+      it 'should send the :with method to end_value' do
+        p = @c.pack(:with => :to_s)
+        p["end_value"].should be_a String
+        p["end_value"].to_f.should eq(@c.end_value)
+      end
     end
   end
 end
 
 describe Change::Gradual do
   describe '#pack' do
-    context 'in general' do
-      before :all do
-        @c = Change::Gradual.new(200,2.5,3.3,4.5)
-        @p = @c.pack
-      end
-      
-      it 'should return a Hash' do
-        @p.should be_a Hash
-      end
-      
-      it 'should have "type", "value", and "impending" keys' do
-        @p.should have_key("type")
-        @p.should have_key("value")
-        @p.should have_key("impending")
-      end
-      
-      it 'should assign "Gradual" to "type" key' do
-        @p["type"].should eq("Gradual")
-      end
-      
-      it 'should assign value to "value" key' do
-        @p["value"].should eq(@c.value)
-      end
-      
-      it 'should assign impending to "impending" key' do
-        @p["impending"].should eq(@c.impending)
-      end
+    before :all do
+      @c = Change::Gradual.linear(200,2.5)
+      @p = @c.pack
     end
     
-    context 'elapsed and remaining are 0' do
-      before :all do
-        @c = Change::Gradual.new(200,2.5)
-        @p = @c.pack
-      end
-      
-      it 'should *only* have "type", "value", and "impending" keys' do
-        @p.keys.sort.should eq(["impending","type","value"])
-      end
+    it 'should return a Hash' do
+      @p.should be_a Hash
+    end
+    
+    it 'should have "type", "end_value", "duration", "transition", and keys' do
+      @p.keys.sort.should eq(["duration","end_value","transition","type"])
+    end
+    
+    it 'should assign "Gradual" to "type" key' do
+      @p["type"].should eq("Gradual")
+    end
+    
+    it 'should assign end_value to "end_value" key' do
+      @p["end_value"].should eq(@c.end_value)
+    end
+    
+    it 'should assign duration to "duration" key' do
+      @p["duration"].should eq(@c.duration)
+    end
+    
+    it 'should assign start value to "start_value" key' do
+      @p["start_value"].should eq(@c.start_value)
     end
 
-    context 'elapsed is not 0, but remaining is 0' do
-      before :all do
-        @c = Change::Gradual.new(200,2.5,1.1)
-        @p = @c.pack
+    it 'should assign transition to "transition" key' do
+      @p["transition"].should eq(@c.transition)
+    end
+    
+    context 'given :with method' do
+      it 'should send the :with method to end_value' do
+        p = @c.pack(:with => :to_s)
+        p["end_value"].should be_a String
+        p["end_value"].to_f.should eq(@c.end_value)
       end
-      
-      it 'should *only* have "type", "value", "impending", and "elapsed" keys' do
-        @p.keys.sort.should eq(["elapsed","impending","type","value"])
+    end
+    
+    context 'given start value' do
+      it 'should assign start_value to "start_value" ' do
+        c = Change::Gradual.linear(200,2.5,start_value: 20)
+        p = c.pack
+        p.should have_key("start_value")
+        p["start_value"].should eq(c.start_value)
       end
       
-      it 'should assign elapsed to "elapsed" key' do
-        @p["elapsed"].should eq(@c.elapsed)
+      context 'given :with method' do
+        it 'should send the :with method to end_value' do
+          c = Change::Gradual.linear(200,2.5,start_value: 20)
+          p = c.pack(:with => :to_s)
+          p["start_value"].should be_a String
+          p["start_value"].to_f.should eq(c.start_value)
+        end
       end
     end
+  end
+end
+
+describe Change::Gradual::Trimmed do
+  describe '#pack' do
+    before :all do
+      @c = Change::Gradual::Trimmed.linear(200,2.5,preceding:1,remaining:0.5)
+      @p = @c.pack
+    end
     
-    context 'elapsed and remaining are not 0' do
-      before :all do
-        @c = Change::Gradual.new(200,2.5,1.1,2.2)
-        @p = @c.pack
+    it 'should return a Hash' do
+      @p.should be_a Hash
+    end
+    
+    it 'should have "type", "end_value", "duration", "transition", "preceding", "remaining" keys' do
+      @p.keys.sort.should eq(["duration","end_value","preceding","remaining","transition","type"])
+    end
+    
+    it 'should assign "Gradual::Trimmed" to "type" key' do
+      @p["type"].should eq("Gradual::Trimmed")
+    end
+    
+    it 'should assign end_value to "end_value" key' do
+      @p["end_value"].should eq(@c.end_value)
+    end
+    
+    it 'should assign duration to "duration" key' do
+      @p["duration"].should eq(@c.duration)
+    end
+    
+    it 'should assign transition to "transition" key' do
+      @p["transition"].should eq(@c.transition)
+    end
+
+    it 'should assign preceding to "preceding" key' do
+      @p["preceding"].should eq(@c.preceding)
+    end
+    
+    it 'should assign remaining to "remaining" key' do
+      @p["remaining"].should eq(@c.remaining)
+    end
+    
+    context 'given :with method' do
+      it 'should send the :with method to end_value' do
+        p = @c.pack(:with => :to_s)
+        p["end_value"].should be_a String
+        p["end_value"].to_f.should eq(@c.end_value)
       end
-      
-      it 'should *only* have "type", "value", "impending", "elapsed", and "remaining" keys' do
-        @p.keys.sort.should eq(["elapsed","impending","remaining","type","value"])
+    end
+    
+    context 'given start value' do
+      it 'should assign start_value to "start_value" ' do
+        c = Change::Gradual.linear(200,2.5,start_value: 20).trim(0.5,0.5)
+        p = c.pack
+        p.should have_key("start_value")
+        p["start_value"].should eq(c.start_value)
       end
       
-      it 'should assign remaining to "remaining" key' do
-        @p["remaining"].should eq(@c.remaining)
+      context 'given :with method' do
+      it 'should send the :with method to end_value' do
+        c = Change::Gradual.linear(200,2.5,start_value: 20).trim(0.5,0.5)
+        p = c.pack(:with => :to_s)
+        p["start_value"].should be_a String
+        p["start_value"].to_f.should eq(c.start_value)
+        end
       end
     end
   end
@@ -113,18 +177,25 @@ describe Change do
         @c2.should be_a Change::Immediate
       end
       
-      it 'should successfully unpack the change value' do
-        @c2.value.should eq @c.value
+      it 'should successfully unpack the change end_value' do
+        @c2.end_value.should eq @c.end_value
       end
       
-      it 'should successfully unpack the change duration' do
-        @c2.duration.should eq @c.duration
+      context 'pack/unpack using :with method' do
+        it 'should use given :with method to convert end_value' do
+          c = Change::Immediate.new(0.5)
+          h = c.pack(:with => :to_s)
+          c2 = Change.unpack(h)
+          c2.end_value.should be_a String
+          c3 = Change.unpack(h, :with => :to_f)
+          c3.end_value.should be_a Float
+        end
       end
     end
     
     context 'given a packed gradual change' do
       before :all do
-        @c = Change::Gradual.new(0.3,1.5,1.1,0.2)
+        @c = Change::Gradual.sigmoid(0.3,1.5)
         @a = @c.pack
         @c2 = Change.unpack(@a)
       end
@@ -133,21 +204,101 @@ describe Change do
         @c2.should be_a Change::Gradual
       end
       
-      it 'should successfully unpack the change value' do
-        @c2.value.should eq @c.value
+      it 'should unpack the end_value' do
+        @c2.end_value.should eq @c.end_value
+      end
+      
+      it 'should unpack the change duration' do
+        @c2.duration.should eq @c.duration
+      end
+
+      it 'should unpack the change transition' do
+        @c2.transition.should eq @c.transition
+      end
+      
+      it 'should unpack the change start_value' do
+        @c2.start_value.should eq @c.start_value
       end
       
-      it 'should successfully unpack the change impending (duration)' do
-        @c2.impending.should eq @c.impending
+      context 'pack/unpack using :with method' do
+        it 'should use given :with method to convert end_value' do
+          c = Change::Gradual.linear(0.5,2)
+          h = c.pack(:with => :to_s)
+          c2 = Change.unpack(h)
+          c2.end_value.should be_a String
+          c3 = Change.unpack(h, :with => :to_f)
+          c3.end_value.should be_a Float
+        end
+        
+        context 'when change start_value is not nil' do
+          it 'should use given :with method to convert start_value' do
+            c = Change::Gradual.linear(0.5,2,start_value: 0.1)
+            h = c.pack(:with => :to_s)
+            c2 = Change.unpack(h)
+            c2.start_value.should be_a String
+            c3 = Change.unpack(h, :with => :to_f)
+            c3.start_value.should be_a Float
+          end
+        end
+      end
+    end
+    
+    context 'given a packed gradual (trimmed) change' do
+      before :all do
+        @c = Change::Gradual::Trimmed.sigmoid(0.3,1.5,preceding:0.1,remaining:0.1)
+        @a = @c.pack
+        @c2 = Change.unpack(@a)
       end
       
-      it 'should successfully unpack the change elapsed' do
-        @c2.elapsed.should eq @c.elapsed
+      it 'should return a Change::Gradual' do
+        @c2.should be_a Change::Gradual
+      end
+      
+      it 'should successfully unpack the end_value' do
+        @c2.end_value.should eq @c.end_value
+      end
+      
+      it 'should successfully unpack the change duration' do
+        @c2.duration.should eq @c.duration
       end
 
+      it 'should successfully unpack the change transition' do
+        @c2.transition.should eq @c.transition
+      end
+      
+      it 'should unpack the change start_value' do
+        @c2.start_value.should eq @c.start_value
+      end
+      
+      it 'should successfully unpack the change preceding' do
+        @c2.preceding.should eq @c.preceding
+      end
+      
       it 'should successfully unpack the change remaining' do
         @c2.remaining.should eq @c.remaining
-      end      
-    end
+      end
+      
+      context 'pack/unpack using :with method' do
+        it 'should use given :with method to convert end_value' do
+          c = Change::Gradual.linear(0.5,2).trim(0.4,0.3)
+          h = c.pack(:with => :to_s)
+          c2 = Change.unpack(h)
+          c2.end_value.should be_a String
+          c3 = Change.unpack(h, :with => :to_f)
+          c3.end_value.should be_a Float
+        end
+        
+        context 'when change start_value is not nil' do
+          it 'should use given :with method to convert start_value' do
+            c = Change::Gradual.linear(0.5,2,start_value: 0.1).trim(0.4,0.3)
+            h = c.pack(:with => :to_s)
+            c2 = Change.unpack(h)
+            c2.start_value.should be_a String
+            c3 = Change.unpack(h, :with => :to_f)
+            c3.start_value.should be_a Float
+          end
+        end
+      end
+    end    
   end
 end

data/spec/notation/packing/part_packing_spec.rb

@@ -7,7 +7,7 @@ describe Part do
       notes: Note.split_parse("/4Bb2 /8 /8F3= /2F3 /4Bb2 /8 /8F3= /2F3"),
       dynamic_changes: {
         1 => Change::Immediate.new(Dynamics::PP),
-        2 => Change::Gradual.new(Dynamics::FF, 2.0)
+        2 => Change::Gradual.linear(Dynamics::FF, 2.0)
       }
     )
     

data/spec/notation/packing/score_packing_spec.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 measured_score = Score::Measured.new(FOUR_FOUR,120) do |s|
+  s.meter_changes[1] = Change::Immediate.new(THREE_FOUR)
   s.program = Program.new([0...2, 0...2,2...4,0...2])
   s.parts["lead"] = Part.new(Dynamics::MF) do |p|
     riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
@@ -58,9 +59,9 @@ describe Score::Measured do
       end
     end
 
-    it 'should pack meter change values as strings' do
+    it 'should pack meter change end values as strings' do
       @h['meter_changes'].each do |offset,packed_v|
-        packed_v[0].should be_a String
+        packed_v["end_value"].should be_a String
       end
     end
     

data/spec/notation/util/function_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Function::Constant do
+  it 'should always return the same value' do
+    f = Function::Constant.new(20)
+    f.at(0).should eq(20)
+    f.at(-1000).should eq(20)
+    f.at(1000).should eq(20)
+  end
+end
+
+describe Function::Linear do
+  it 'should evaluate along the line going between the two initial points' do
+    f = Function::Linear.new([5,10],[7,11])
+    f.at(4).should eq(9.5)
+    f.at(5).should eq(10)
+    f.at(6).should eq(10.5)
+    f.at(7).should eq(11)
+    f.at(8).should eq(11.5)
+  end
+end
+
+describe Function::Sigmoid do
+  it 'should evaluate along the line going between the two initial points' do
+    f = Function::Sigmoid.new([5,10],[7,11])
+    f.at(4).should be < 10
+    f.at(5).should eq(10)
+    f.at(6).should eq(10.5)
+    f.at(7).should eq(11)
+    f.at(8).should be > 11
+  end
+  
+  describe '.find_y0' do
+    it 'should return the starting y-value for the given sigmoid domain' do
+      x0, x1 = 3, 6
+      y0, y1 = 5, 10
+      f = Function::Sigmoid.new([x0,y0],[x1,y1])
+      pt = [4,f.at(4)]
+      y0_ = Function::Sigmoid.find_y0(x0..x1, pt, y1)
+      y0_.should eq(y0)
+    end
+  end
+end

data/spec/notation/util/transition_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Transition do
+  describe '#initialize' do
+    context 'zero-length domain' do
+      it 'should create one piece' do
+        t = Transition.new(Function::Constant.new(3),5..5)
+        t.pieces.size.should eq(1)
+      end
+    end
+    
+    context 'positive-length domain' do
+      it 'should create two pieces' do
+        t = Transition.new(Function::Linear.new([0,0],[2,1]),3..5)
+        t.pieces.size.should eq(2)
+      end
+    end
+  end
+  
+  describe '#at' do
+    before :all do
+      @f = Function::Linear.new([0,0],[2,1])
+      @d = 3..5
+      @t = Transition.new(@f,@d)
+    end
+    
+    context 'given value before transition domain starts' do
+      it 'should raise DomainError' do
+        expect { @t.at(@d.first - 1e-5) }.to raise_error(DomainError)
+        expect { @t.at(@d.first - 1e5) }.to raise_error(DomainError)
+      end
+    end
+    
+    context 'given value in transition domain' do
+      it 'should not raise DomainError' do
+        @d.entries.each {|x| expect { @t.at(x) }.to_not raise_error }
+      end
+      
+      it 'should calculate return value using the transition function' do
+        @d.entries.each {|x| @t.at(x).should eq(@f.at(x)) }
+      end
+    end
+    
+    context 'given value after transition domain' do
+      it 'should return same value as at the end of transition domain' do
+        @t.at(@d.last + 1e-5).should eq(@t.at(@d.last))
+        @t.at(@d.last + 1e5).should eq(@t.at(@d.last))
+      end
+    end
+  end
+end

data/spec/notation/util/value_computer_spec.rb

@@ -1,10 +1,11 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe ValueComputer do
-  describe '#value_at' do
+  describe '#at' do
     before :all do
-      @value_change1 = Change::Immediate.new(0.6)
-      @value_change2 = Change::Gradual.new(0.6, 1.0)
+      @immed_change = Change::Immediate.new(0.6)
+      @lin_change = Change::Gradual.linear(0.6, 1.0)
+      @sigm_change = Change::Gradual.sigmoid(0.6, 1.0)
     end
     
     context "constant value" do
@@ -13,134 +14,89 @@ describe ValueComputer do
       end
       
       it "should always return default value if no changes are given" do
-        [ValueComputer.domain_min, -1000, 0, 1, 5, 100, 10000, ValueComputer.domain_max].each do |offset|
-          @comp.value_at(offset).should eq(0.5)
+        [ValueComputer::DOMAIN_MIN, -1000, 0, 1, 5, 100, 10000, ValueComputer::DOMAIN_MAX].each do |offset|
+          @comp.at(offset).should eq(0.5)
         end
       end
     end
     
     context "one change, no transition" do
       before :each do
-        @comp = ValueComputer.new 0.5, 1.0 => @value_change1
+        @comp = ValueComputer.new 0.5, 1.0 => @immed_change
       end
       
       it "should be the default value just before the first change" do
-        @comp.value_at(0.999).should eq(0.5)
+        @comp.at(0.999).should eq(0.5)
       end
           
       it "should transition to the second value immediately" do
-        @comp.value_at(1.0).should eq(0.6)
+        @comp.at(1.0).should eq(0.6)
       end
 
       it "should be the first value for all time before" do
-        @comp.value_at(ValueComputer.domain_min).should eq(0.5)
+        @comp.at(ValueComputer::DOMAIN_MIN).should eq(0.5)
       end
       
       it "should be at the second value for all time after" do
-        @comp.value_at(ValueComputer.domain_max).should eq(0.6)
+        @comp.at(ValueComputer::DOMAIN_MAX).should eq(0.6)
       end
     end
     
     context "one change, linear transition" do
       before :each do
-        @comp = ValueComputer.new 0.2, 1.0 => @value_change2
+        @comp = ValueComputer.new 0.2, 1.0 => @lin_change
       end
       
       it "should be the first (starting) value just before the second value" do
-        @comp.value_at(0.999).should eq(0.2)
+        @comp.at(0.999).should eq(0.2)
       end
           
       it "should be the first (starting) value exactly at the second value" do
-        @comp.value_at(1.0).should eq(0.2)
+        @comp.at(1.0).should eq(0.2)
       end
     
       it "should be 1/4 to the second value after 1/4 transition duration has elapsed" do
-        @comp.value_at(Rational(5,4).to_f).should eq(0.3)
+        @comp.at(Rational(5,4).to_f).should eq(0.3)
       end
     
       it "should be 1/2 to the second value after 1/2 transition duration has elapsed" do
-        @comp.value_at(Rational(6,4).to_f).should eq(0.4)
+        @comp.at(Rational(6,4).to_f).should eq(0.4)
       end
     
       it "should be 3/4 to the second value after 3/4 transition duration has elapsed" do
-        @comp.value_at(Rational(7,4).to_f).should eq(0.5)
+        @comp.at(Rational(7,4).to_f).should eq(0.5)
       end
     
       it "should be at the second value after transition duration has elapsed" do
-        @comp.value_at(Rational(8,4).to_f).should eq(0.6)
+        @comp.at(Rational(8,4).to_f).should eq(0.6)
       end
     end
 
-  #  context "one change, sigmoid transition" do
-  #    before :all do
-  #      @cases = [
-  #        { :start_value => 0, :end_value => 1, :offset => 0, :duration => 1.0, :abruptness => 0.75 },
-  #        { :start_value => 0.25, :end_value => 0.75, :offset => 1.0, :duration => 2.0, :abruptness => 0.75 },
-  #        { :start_value => -1.0, :end_value => 5.5, :offset => 2.4, :duration => 20, :abruptness => 0.75 },
-  #        { :start_value => 10, :end_value => 100, :offset => 20, :duration => 4, :abruptness => 0.75 },
-  #      ]
-  #  
-  #      @computers = {}
-  #      @cases.each do |case_hash|
-  #        start_value = case_hash[:start_value]
-  #        offset = case_hash[:offset]
-  #        end_value = case_hash[:end_value]
-  #        duration = case_hash[:duration]
-  #        #abruptness = case_hash[:abruptness]
-  #        
-  #        change = Change::Gradual.new(end_value, duration)
-  #        @computers[case_hash] = ValueComputer.new start_value, offset => change
-  #        # @computers[case_hash].plot_range(offset..(offset + duration), 0.01)
-  #      end
-  #    end
-  #  
-  #    it "should be the first (starting) value just before the value change offset" do
-  #      @computers.each do |case_hash, comp|
-  #        comp.value_at(case_hash[:offset] - 0.0001).should eq(case_hash[:start_value])
-  #      end
-  #    end
-  #        
-  #    it "should be very nearly the first (starting) value exactly at the value change offset" do
-  #      @computers.each do |case_hash, comp|
-  #        comp.value_at(case_hash[:offset]).should be_within(0.0001).of(case_hash[:start_value])
-  #      end
-  #    end
-  #  
-  #    it "should be within 1% of start/end difference away from the start value after 1/4 transition duration has elapsed" do
-  #      @computers.each do |case_hash, comp|
-  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.25)
-  #        start_value = case_hash[:start_value]
-  #        end_value = case_hash[:end_value]
-  #        tolerance = 0.01 * (end_value - start_value)
-  #        comp.value_at(test_offset).should be_within(tolerance).of(start_value)
-  #      end
-  #    end
-  #  
-  #    it "should be half way to the end value after half way through transition" do
-  #      @computers.each do |case_hash, comp|
-  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.5)
-  #        start_value = case_hash[:start_value]
-  #        expected_value = start_value + (case_hash[:end_value] - start_value) * 0.5
-  #        comp.value_at(test_offset).should be_within(0.0001).of(expected_value)
-  #      end
-  #    end
-  #  
-  #    it "should be within 1% of start/end difference away from the end value after 3/4 transition duration has elapsed" do
-  #      @computers.each do |case_hash, comp|
-  #        test_offset = case_hash[:offset] + (case_hash[:duration] * 0.75)
-  #        start_value = case_hash[:start_value]
-  #        end_value = case_hash[:end_value]
-  #        tolerance = 0.01 * (end_value - start_value)
-  #        comp.value_at(test_offset).should be_within(tolerance).of(end_value)
-  #      end
-  #    end
-  #  
-  #    it "should be at the second value after transition duration has elapsed" do
-  #      @computers.each do |case_hash, comp|
-  #        comp.value_at(case_hash[:offset] + case_hash[:duration]).should eq(case_hash[:end_value])
-  #      end
-  #    end
-  #  end
+    context "one change, sigmoid transition" do
+      before :each do
+        @comp = ValueComputer.new 0.2, 1.0 => @sigm_change
+      end
+      
+      it "should be the first (starting) value just before the second value" do
+        @comp.at(0.999).should eq(0.2)
+      end
+          
+      it "should be the first (starting) value exactly at the second value" do
+        @comp.at(1.0).should eq(0.2)
+      end
+    
+      it "should be 1/2 to the second value after 1/2 transition duration has elapsed" do
+        @comp.at(1.5).should be_within(1e-5).of(0.4)
+      end
+    
+      it "should be at the second value exactly where transition duration has elapsed" do
+        @comp.at(2).should eq(0.6)
+      end
+      
+      it "should be at the second value just after transition duration has elapsed" do
+        @comp.at(2.001).should eq(0.6)
+      end      
+    end
   end
 end