musicality 0.2.0 → 0.3.0

data/spec/notation/conversion/change_conversion_spec.rb

@@ -7,17 +7,156 @@ describe Change::Immediate do
       c.offsets(44).should eq([44])
     end
   end
+  
+  describe '#remap' do
+    it 'should return a clone of the change' do
+      c = Change::Immediate.new(12)
+      c2 = c.remap(1,{})
+      c2.should eq(c)
+      c2.should_not be c
+    end
+  end
+  
+  describe '#to_transition' do
+    before :all do
+      @ch = Change::Immediate.new(20)
+      @off = 0
+      @f = @ch.to_transition(@off,0)
+    end
+    
+    it 'should return a peicewise function' do
+      @f.should be_a Function::Piecewise
+    end
+    
+    it 'should return a function defined from base offset to DOMAIN_MAX' do
+      @f.domain_include?(@off).should be true
+      @f.domain_include?(Function::DOMAIN_MAX).should be true
+    end
+    
+    it 'should return change value from base offset onward' do
+      @f.at(@off).should eq(@ch.end_value)
+      @f.at(@off+1).should eq(@ch.end_value)
+      @f.at(@off+1000).should eq(@ch.end_value)
+    end
+  end
 end
 
 describe Change::Gradual do
+  before :all do
+    @change = Change::Gradual.linear(100,1.5)
+    @base = 25.5
+  end
+  
   describe '#offsets' do
     before :all do
-      @change = Change::Gradual.new(100,1.5,0.5,0.25)
-      @base = 25.5
       @offsets = @change.offsets(@base)
     end
     
-    it 'should return array with 4 elements' do
+    it 'should return array with 2 elements' do
+      @offsets.size.should eq(2)
+    end
+    
+    it 'should include the given base offset' do
+      @offsets.should include(@base)
+    end
+    
+    it 'should include the base offset + duration' do
+      @offsets.should include(@base + @change.duration)
+    end
+  end
+  
+  describe '#remap' do
+    before :all do
+      @c2 = @change.remap(@base, @base => 3, (@base + @change.duration) => 5)
+    end
+    
+    it 'should return a new Gradual' do
+      @c2.should be_a(Change::Gradual)
+      @c2.should_not be(@change)
+    end
+    
+    it 'should keep end value, and change duration based on given offset map' do
+      @c2.end_value.should eq(@change.end_value)
+      @c2.duration.should eq(2)
+    end
+  end
+  
+  describe '#to_transition' do
+    { 'linear transition' => Change::Gradual.linear(130,20),
+      'sigmoid transition' => Change::Gradual.sigmoid(130,20)
+    }.each do |descr, change|
+      context descr do
+        before :all do
+          @offset = 3
+          @start_value = 50
+          @func = @change.to_transition(@offset, @start_value)
+        end
+        
+        it 'should return a piecewise function' do
+          @func.should be_a Function::Piecewise
+        end
+        
+        it 'should return a function that is undefined before base offset' do
+          @func.domain_include?(@offset-1e-5).should be false
+          @func.domain_include?(@offset-1e5).should be false
+        end
+        
+        it 'should return a function defined from base offset to DOMAIN_MAX' do
+          @func.domain_include?(@offset).should be true
+          @func.domain_include?(@offset + @change.duration/2.0).should be true
+          @func.domain_include?(@offset + @change.duration).should be true
+          @func.domain_include?(@offset + @change.duration + 1).should be true
+          @func.domain_include?(Function::DOMAIN_MAX).should be true
+        end
+  
+        it 'should make function that evaluates to start_value at start offset' do
+          @func.at(@offset).should eq(@start_value)
+        end
+  
+        it 'should make function that evaluates to end_value at start offset + duration' do
+          @func.at(@offset + @change.duration).should eq(@change.end_value)
+        end
+        
+        it 'should make function that evaluates to 1/2 between start/end value at 1/2 between start/end offset' do
+          tgt = (@change.end_value + @start_value) / 2.0
+          @func.at(@offset + @change.duration/2.0).should be_within(1e-5).of(tgt)
+        end
+        
+        it 'should make function that evaluates to end value after change has elapsed' do
+          @func.at(@offset + @change.duration + 1).should eq(@change.end_value)
+        end
+      end
+    end
+      
+    context 'start value already defined in change' do
+      { 'linear transition' => Change::Gradual.linear(130,20,start_value:80),
+        'sigmoid transition' => Change::Gradual.sigmoid(130,20,start_value:80)
+      }.each do |descr, change|
+        context descr do
+          it 'should produce a function that begins at already-defined start value' do
+            offset = 3
+            start_value = 50
+            func = change.to_transition(offset, start_value)
+            func.at(offset).should eq(change.start_value)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Change::Gradual::Trimmed do
+  before :all do
+    @change = Change::Gradual.linear(100,1.5.to_r).to_trimmed(0.5.to_r,0.5.to_r)
+    @base = 25.5.to_r
+  end
+  
+  describe '#offsets' do
+    before :all do
+      @offsets = @change.offsets(@base)
+    end
+    
+    it 'should return array with 2 elements' do
       @offsets.size.should eq(4)
     end
     
@@ -25,16 +164,84 @@ describe Change::Gradual do
       @offsets.should include(@base)
     end
     
-    it 'should include the base offset - elapsed' do
-      @offsets.should include(@base - @change.elapsed)
+    it 'should include the base offset - preceding' do
+      @offsets.should include(@base - @change.preceding)
+    end
+    
+    it 'should include the base offset + remaining' do
+      @offsets.should include(@base + @change.remaining)
+    end
+    
+    it 'should include the base offset - preceding + duration' do
+      @offsets.should include(@base - @change.preceding + @change.duration)
+    end
+  end
+  
+  describe '#remap' do
+    before :all do
+      @offsets = { @base => 3, (@base - @change.preceding) => 0,
+        (@base + @change.remaining) => 5, (@base - @change.preceding + @change.duration) => 7 }
+      @c2 = @change.remap(@base, @offsets)
     end
     
-    it 'should include the base offset + impending' do
-      @offsets.should include(@base + @change.impending)
+    it 'should return a new Gradual::Trimmed' do
+      @c2.should be_a(Change::Gradual::Trimmed)
+      @c2.should_not be(@change)
     end
     
-    it 'should include the base offset + impending + remaining' do
-      @offsets.should include(@base + @change.impending + @change.remaining)
+    it 'should keep end value, and change duration based on given offset map' do
+      @c2.end_value.should eq(@change.end_value)
+      @c2.duration.should eq(7)
+      @c2.preceding.should eq(3)
+      @c2.remaining.should eq(2)
+    end
+  end
+  
+  describe '#to_transition' do
+    Change::Gradual::TRANSITIONS.each do |transition|
+      context "#{transition} transition" do
+        [nil,35].each do |start_val|
+          context "change start_value = #{start_val}" do
+            before :all do
+              untrimmed = Change::Gradual.new(130,20, transition, start_value: start_val)
+              untrimmed_offset = 0
+              untrimmed_start_val = 50
+              @untrimmed_trans = untrimmed.to_transition(untrimmed_offset, untrimmed_start_val)
+              
+              trimmed = untrimmed.trim(5,3)
+              trimmed_offset = untrimmed_offset + trimmed.preceding
+              trimmed_start_val = @untrimmed_trans.at(trimmed_offset)
+              @trimmed_trans = trimmed.to_transition(trimmed_offset, trimmed_start_val)
+              
+              @xrange = trimmed_offset..(trimmed_offset + trimmed.remaining)
+            end
+            
+            it 'should produce function that is undefined before trimmed domain' do
+              @trimmed_trans.domain_include?(@xrange.first-1).should be false
+            end
+    
+            it 'should produce function that is defined for trimmed domain' do
+              @trimmed_trans.domain_include?(@xrange.first).should be true
+              @trimmed_trans.domain_include?((@xrange.first + @xrange.last)/2.0).should be true
+              @trimmed_trans.domain_include?(@xrange.last).should be true
+            end
+            
+            it 'should produce function that is defined after trimmed domain' do
+              @trimmed_trans.domain_include?(@xrange.last+1).should be true
+              @trimmed_trans.domain_include?(Function::DOMAIN_MAX).should be true
+            end
+            
+            it 'should produce function that stays at end value after transition' do
+              @trimmed_trans.at(@xrange.last + 1).should eq(@trimmed_trans.at(@xrange.last))
+            end
+            
+            it 'should produce function that samples same as equivalent untrimmed' do
+              srate = 50
+              @trimmed_trans.sample(@xrange, srate).should eq(@untrimmed_trans.sample(@xrange, srate))
+            end            
+          end
+        end
+      end
     end
   end
 end

data/spec/notation/conversion/measure_note_map_spec.rb

@@ -38,10 +38,10 @@ describe 'Conversion.measure_note_map' do
       @score = Score::Measured.new(@start_meter, 120,
         meter_changes: { @first_mc_off => Change::Immediate.new(@new_meter) },
         tempo_changes: {
-          "1/2".to_r => Change::Gradual.new(100,1),
+          "1/2".to_r => Change::Gradual.linear(100,1),
           2 => Change::Immediate.new(120),
           3 => Change::Immediate.new(100),
-          3.1 => Change::Gradual.new(100,1),
+          3.1 => Change::Gradual.linear(100,1),
           5 => Change::Immediate.new(120),
           6 => Change::Immediate.new(100),
         }

data/spec/notation/conversion/note_time_converter_spec.rb

@@ -1,13 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe NoteTimeConverter do
+describe NoteTimeConverter::Unmeasured do
   describe '#notes_per_second_at' do
     it 'should convert tempo using Tempo::QNPM.to_nps' do
       tc = ValueComputer.new(
-        120, 1 => Change::Gradual.new(100,1), 2 => Change::Gradual.new(150,1))
-      converter = NoteTimeConverter.new(tc,200)
+        120, 1 => Change::Gradual.linear(100,1), 2 => Change::Gradual.linear(150,1))
+      converter = NoteTimeConverter::Unmeasured.new(tc,200)
       (0..2).step(0.2).each do |offset|
-        nps = Tempo::QNPM.to_nps(tc.value_at(offset))
+        nps = Tempo::QNPM.to_nps(tc.at(offset))
         converter.notes_per_second_at(offset).should eq(nps)
       end
     end
@@ -18,7 +18,7 @@ describe NoteTimeConverter do
       before :each do
         @tempo_computer = ValueComputer.new 120
         sample_rate = 48
-        @converter = NoteTimeConverter.new(@tempo_computer, sample_rate)
+        @converter = NoteTimeConverter::Unmeasured.new(@tempo_computer, sample_rate)
       end
   
       it "should return a time of zero when note end is zero." do
@@ -34,9 +34,9 @@ describe NoteTimeConverter do
     context "linear tempo-change" do
       before :each do
         @tempo_computer = ValueComputer.new(
-          120, 1 => Change::Gradual.new(60, 1))
+          120, 1 => Change::Gradual.linear(60, 1))
         sample_rate = 200
-        @converter = NoteTimeConverter.new(@tempo_computer, sample_rate)
+        @converter = NoteTimeConverter::Unmeasured.new(@tempo_computer, sample_rate)
       end
   
       it "should return a time of zero when note end is zero." do
@@ -53,12 +53,12 @@ describe NoteTimeConverter do
     end
   end
   
-  describe "#map_note_offsets_to_time_offsets" do
+  describe "#note_time_map" do
     context "constant tempo" do
       before :each do 
         @tempo_computer = ValueComputer.new 120
         sample_rate = 4800
-        @converter = NoteTimeConverter.new(
+        @converter = NoteTimeConverter::Unmeasured.new(
           @tempo_computer, sample_rate)
       end
   
@@ -79,3 +79,85 @@ describe NoteTimeConverter do
     end
   end
 end
+
+describe NoteTimeConverter::Measured do
+  describe '#notes_per_second_at' do
+    it 'should convert tempo using Tempo::BPM.to_nps' do
+      tc = ValueComputer.new(120, 1 => Change::Gradual.linear(100,1),
+                             2 => Change::Gradual.linear(150,1))
+      bdc = ValueComputer.new(0.25.to_r, 2.5 => Change::Immediate.new(0.375.to_r))
+      converter = NoteTimeConverter::Measured.new(tc,bdc,200)
+      (0..3.2).step(0.2).each do |offset|
+        nps = Tempo::BPM.to_nps(tc.at(offset), bdc.at(offset))
+        converter.notes_per_second_at(offset).should eq(nps)
+      end
+    end
+  end
+  
+  describe "#time_elapsed" do
+    context "constant tempo, beat duration" do
+      before :each do
+        @tempo_computer = ValueComputer.new 120
+        @bdur_computer = ValueComputer.new Rational(1,4)
+        sample_rate = 48
+        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+      end
+  
+      it "should return a time of zero when note end is zero." do
+        @converter.time_elapsed(0, 0).should eq(0)
+      end
+      
+      it "should return a time of 1 second when note end is equal to the initial notes-per-second" do
+        note_end = @converter.notes_per_second_at(0)
+        @converter.time_elapsed(0, note_end).should eq(1)
+      end
+    end
+    
+    context "linear tempo-change, constant beat duration" do
+      before :each do
+        @tempo_computer = ValueComputer.new(120, 1 => Change::Gradual.linear(60, 1))
+        @bdur_computer = ValueComputer.new Rational(1,4)
+        sample_rate = 200
+        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+      end
+  
+      it "should return a time of zero when note end is zero." do
+        @converter.time_elapsed(0.0, 0.0).should eq(0.0)
+      end
+  
+      it "should return a time of 3 sec during a 1-note long transition from 120bpm to 60bpm" do
+        @converter.notes_per_second_at(1.0).should eq(0.5)
+        @converter.notes_per_second_at(2.0).should eq(0.25)
+  
+        @converter.time_elapsed(1.0, 2.0).should be_within(0.05).of(2.77)
+      end
+  
+    end
+  end
+  
+  describe "#note_time_map" do
+    context "constant tempo, beat duration" do
+      before :each do 
+        @tempo_computer = ValueComputer.new 120
+        @bdur_computer = ValueComputer.new Rational(1,4)
+        sample_rate = 4800
+        @converter = NoteTimeConverter::Measured.new(@tempo_computer, @bdur_computer, sample_rate)
+      end
+  
+      it "should map offset 0.0 to time 0.0" do
+        map = @converter.note_time_map [0.0]
+        map[0.0].should eq(0.0)
+      end
+
+      it "should map offset 0.25 to time 0.5" do
+        map = @converter.note_time_map [0.0, 0.25]
+        map[0.25].should be_within(0.01).of(0.5)
+      end
+      
+      it "should map offset 1.0 to time 2.0" do
+        map = @converter.note_time_map [0.0, 1.0]
+        map[1.0].should be_within(0.01).of(2.0)
+      end
+    end
+  end
+end

data/spec/notation/conversion/{measured_score_conversion_spec.rb → score_conversion_spec.rb}

@@ -8,7 +8,7 @@ describe Score::Measured do
         dynamic_changes: {
           1 => Change::Immediate.new(Dynamics::MF),
           5 => Change::Immediate.new(Dynamics::FF),
-          6 => Change::Gradual.new(Dynamics::MF,2),
+          6 => Change::Gradual.linear(Dynamics::MF,2),
           14 => Change::Immediate.new(Dynamics::PP),
         }
       )
@@ -16,7 +16,7 @@ describe Score::Measured do
     @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
     tcs = {
       0 => Change::Immediate.new(120),
-      4 => Change::Gradual.new(60,2),
+      4 => Change::Gradual.linear(60,2),
       11 => Change::Immediate.new(110)
     }
     mcs = {
@@ -87,7 +87,7 @@ describe Score::Measured do
       end
       
       it 'should map start meter to offset 0' do
-        @mdurs[0].should eq(@score.start_meter.measure_duration)
+        @mdurs[0.to_r].should eq(@score.start_meter.measure_duration)
       end
     end
     
@@ -107,7 +107,7 @@ describe Score::Measured do
       end
       
       it 'should begin with meter change at offset 0, instead of start meter' do
-        @mdurs2[0].should eq(@change.value.measure_duration)
+        @mdurs2[0].should eq(@change.end_value.measure_duration)
       end
     end
     
@@ -126,16 +126,51 @@ describe Score::Measured do
       end
       
       it 'should begin with start meter' do
-        @mdurs3[0].should eq(@score3.start_meter.measure_duration)
+        @mdurs3[0.to_r].should eq(@score3.start_meter.measure_duration)
       end
     end
   end
   
-  describe '#to_unmeasured' do
-    it 'should use MeasuredScoreConverter#convert_score' do
-      nscore1 = @score.to_unmeasured
-      nscore2 = MeasuredScoreConverter.new(@score).convert_score
+  describe '#to_timed' do
+    it 'should use ScoreConverter::Measured#convert_score' do
+      nscore1 = @score.to_timed(200)
+      nscore2 = ScoreConverter::Measured.new(@score,200).convert_score
       nscore1.should eq(nscore2)
     end
   end
 end
+
+describe Score::Unmeasured do
+  before :all do
+    @parts = {
+      "piano" => Part.new(Dynamics::MP,
+        notes: [Note.quarter(C4), Note.eighth(F3), Note.whole(C4), Note.half(D4)]*12,
+        dynamic_changes: {
+          1 => Change::Immediate.new(Dynamics::MF),
+          5 => Change::Immediate.new(Dynamics::FF),
+          6 => Change::Gradual.linear(Dynamics::MF,2),
+          14 => Change::Immediate.new(Dynamics::PP),
+        }
+      )
+    }
+    @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
+    tcs = {
+      0 => Change::Immediate.new(120),
+      4 => Change::Gradual.linear(60,2),
+      11 => Change::Immediate.new(110)
+    }
+    @score = Score::Unmeasured.new(120,
+      parts: @parts,
+      program: @prog,
+      tempo_changes: tcs,
+    )
+  end
+  
+  describe '#to_timed' do
+    it 'should use ScoreConverter::Unmeasured#convert_score' do
+      nscore1 = @score.to_timed(200)
+      nscore2 = ScoreConverter::Unmeasured.new(@score,200).convert_score
+      nscore1.should eq(nscore2)
+    end
+  end
+end