musicality 0.3.0 → 0.5.0

data/spec/composition/util/compound_sequence_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe CompoundSequence do
+  seqs = [ AddingSequence.new([1,1,0,2,-1]),
+           RepeatingSequence.new([0,1,0,5,-13]) ]
+  
+  describe "#at" do
+    context 'given single offset' do
+      [ :+, :* ].each do |sym|
+        cseq = CompoundSequence.new(sym,seqs)
+        context "given #{sym} as combine method" do
+          it "should get a value from each sequence using #at and combine using #{sym}" do
+            [0, 1, -5, 33].each do |offset|
+              vals = seqs.map {|s| s.at(offset) }
+              val = vals[1..-1].inject(vals.first,sym)
+              val2 = cseq.send(:at,offset)
+              val2.should eq(val)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  { :at => [[-5,1,33,2,0,-11], [-3,-2,-1,0,1,2,-3,-2,-1]],
+    :take => [ 0, 5, 10, 13 ],
+    :take_back => [ 0, 2, 6, 15 ],
+    :over => [ 0..12, -3...5, -10..-3 ]
+  }.each do |method,args|
+    describe "##{method}" do
+      [ :+, :* ].each do |sym|
+        cseq = CompoundSequence.new(sym,seqs)
+        context "given #{sym} as combine method" do
+          it "should get values from each sequence using #{method} and combine each set of values using #{sym}" do
+            args.each do |arg|
+              enums = seqs.map {|s| s.send(method,arg) }
+              n = arg.is_a?(Fixnum) ? arg : arg.size
+              vals = Array.new(n) do |i|
+                _vals = enums.map {|e| e.next }
+                _vals[1..-1].inject(_vals.first,sym)
+              end
+              vals2 = cseq.send(method,arg).to_a
+              vals2.should eq(vals)
+            end
+          end
+        end
+      end
+    end    
+  end
+end

data/spec/composition/util/probabilities_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'set'
+
+describe Probabilities do
+  [:random,:uniform].each do |class_method|
+    describe ".#{class_method}" do
+      it 'should return array of given size, with sum of 1' do
+        (1..10).step(2) do |n|
+          5.times do
+            x = Probabilities.send(class_method,n)
+            x.size.should eq(n)
+            x.inject(0,:+).should eq(1)
+          end
+        end
+      end
+    end
+  end
+  
+  describe '.random' do
+    it 'should return array of all-different values' do
+      x = Probabilities.random(100)
+      Set.new(x).size.should eq(100)
+    end
+  end
+  
+  describe '.uniform' do
+    it 'should return array of all (or all-but-one) same values' do
+      [2,6,10,33,78,100].each do |n|
+        x = Probabilities.uniform(n)
+        y = Set.new(x)
+        (y.size == 1 || y.size == 2).should eq(true)
+        if y.size == 2
+          y.entries[0].should be_within(1e-9).of(y.entries[1])
+        end
+      end
+    end
+  end
+end

data/spec/composition/util/random_sampler_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RandomSampler do
+  describe '#initialize' do
+    context 'given probabilities that do not add up to 1' do
+      it 'should raise ArgumentError' do
+        [ [[1,2],[0.4,0.59]],
+          [[1/2.to_r, 1/4.to_r],[0.5,0.5001]] ].each do |vals,probs|
+          expect { RandomSampler.new(vals,probs) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  before :all do
+    @samplers = [
+      [[ 1/8.to_r, 1/4.to_r, 1/2.to_r ], [0.25, 0.5, 0.25 ]],
+      [[ 1/6.to_r, 1/4.to_r, 1/3.to_r, 1/12.to_r], [0.25,0.25,0.25,0.25]]
+    ].map {|vals,probs| RandomSampler.new(vals,probs) }
+  end
+
+  describe '#sample' do
+    context 'given no arg' do
+      it 'should return a random value, according to the probabilities given at initialization' do
+        @samplers.each do |sampler|
+          counts = Hash[ sampler.values.map {|val| [val,0] } ]
+          1000.times { counts[sampler.sample] += 1 }
+          sampler.values.each_with_index do |val,i|
+            count = counts[val]
+            tgt_prob = sampler.probabilities[i]
+            (count / 1000.to_f).should be_within(0.05).of(tgt_prob)
+          end
+        end
+      end
+    end
+    
+    context 'given number of samples to take' do
+      it 'should return array with the given number of samples' do
+        @samplers.each do |sampler|
+          [1,2,5,10].each do |n|
+            sampler.sample(n).size.should eq(n)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/composition/util/repeating_sequence_spec.rb

@@ -0,0 +1,151 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RepeatingSequence do
+  describe '#initialize' do
+    context 'given an empty pattern' do
+      it 'should raise EmptyError' do
+        expect do
+          RepeatingSequence.new([])
+        end.to raise_error(EmptyError)
+      end
+    end
+  end
+  
+  describe '#pattern_size' do
+    it 'should return the pattern size' do
+      RepeatingSequence.new([1,2,3,4,5]).pattern_size.should eq(5)
+    end
+  end
+  
+  before :all do
+    @pattern = [2,1,5,4,3]
+    @seq = RepeatingSequence.new(@pattern)
+  end
+  
+  describe '#at' do
+    context 'given single offset' do
+      it 'should module index into pattern using given offset' do
+        n = @pattern.size
+        (0..n*2).each do |i|
+          @seq.at(i).should eq(@pattern[i%n])
+        end
+      end
+    end
+    
+    context 'given array of offsets' do
+      context 'not given block' do
+        it 'should return enumerator' do
+          @seq.at([1,2,3]).should be_a Enumerator
+        end
+      end
+      
+      context 'given block' do
+        it 'should yield sequence value for each offset' do
+          [ (0..@seq.pattern_size).to_a, (-@seq.pattern_size..0).to_a,
+           [-5,11,0,-33,2,15,-8] ].each do |offsets|
+            @seq.at(offsets).each_with_index do |val,i|
+              val.should eq(@seq.at(offsets[i]))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#take' do
+    context 'given negative integer' do
+      it 'should raise NegativeError' do
+        expect { @seq.take(-1) }.to raise_error(NegativeError)
+        expect { @seq.take(-10) }.to raise_error(NegativeError)
+      end
+    end
+    
+    context 'given 0' do
+      it 'should return empty array' do
+        @seq.take(0).to_a.should eq([])
+      end
+    end
+    
+    context 'given positive integer' do
+      context 'given block' do
+        it 'should yield the given number of pattern elements in forward direction (repeating as necessary)' do
+          i = 0
+          @seq.take(@pattern.size*2+3) do |n|
+            n.should eq(@seq.at(i))
+            i += 1
+          end
+        end
+      end
+      
+      context 'no block given' do
+        it 'should return an enumerator' do
+          @seq.take(20).should be_a Enumerator
+        end
+      end
+    end
+  end
+  
+  describe '#take_back' do
+    context 'given negative integer' do
+      it 'should raise NegativeError' do
+        expect { @seq.take_back(-1) }.to raise_error(NegativeError)
+        expect { @seq.take_back(-10) }.to raise_error(NegativeError)
+      end
+    end
+    
+    context 'given 0' do
+      it 'should return empty array' do
+        @seq.take_back(0).to_a.should eq([])
+      end
+    end
+    
+    context 'given positive integer' do
+      context 'given block' do
+        it 'should yield the given number of pattern elements in backward direction (repeating as necessary)' do
+          i, m = 0, @pattern.size*2+3
+          @seq.take_back(m) do |n|
+            n.should eq(@seq.at(i-1))
+            i -= 1
+          end
+          (-i).should eq(m)
+        end
+      end
+      
+      context 'no block given' do
+        it 'should return an enumerator' do
+          @seq.take_back(20).should be_a Enumerator
+        end
+      end
+    end
+  end
+  
+  describe '#over' do
+    context 'given empty (invalid) range' do
+      it 'should raise EmptyError' do
+        [ 3...-2, 0...0, 5..2, -3..-5 ].each do |range|
+          expect { @seq.over(range) }.to raise_error(EmptyError)
+        end
+      end
+    end
+    
+    context 'given range over positive indices' do
+      it 'should return seq values at all offsets in range' do
+        [ 0..0, 0..2, 1...10, 4..17 ].each do |range|
+          vals = @seq.over(range).to_a
+          vals2 = range.map {|i| @seq.at(i) }
+          vals.should eq(vals2)
+        end
+      end
+    end
+    
+    context 'given negative min and/or max' do
+      it 'should return seq values at all offsets in range' do
+        [ -5..2, -10..-7, -1...1 ].each do |range|
+          vals = @seq.over(range).to_a
+          vals2 = range.map {|i| @seq.at(i) }
+          vals.should eq(vals2)
+        end
+      end
+    end
+  end
+end

data/spec/notation/conversion/score_conversion_spec.rb

@@ -13,7 +13,7 @@ describe Score::Measured do
         }
       )
     }
-    @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
+    @prog = [0...3,4...7,1...20,17..."45/2".to_r]
     tcs = {
       0 => Change::Immediate.new(120),
       4 => Change::Gradual.linear(60,2),
@@ -63,7 +63,7 @@ describe Score::Measured do
     end
     
     it 'should include offsets from program segments' do
-      @score.program.segments.each do |seg|
+      @score.program.each do |seg|
         @moffs.should include(seg.first)
         @moffs.should include(seg.last)
       end
@@ -153,7 +153,7 @@ describe Score::Unmeasured do
         }
       )
     }
-    @prog = Program.new([0...3,4...7,1...20,17..."45/2".to_r])
+    @prog = [0...3,4...7,1...20,17..."45/2".to_r]
     tcs = {
       0 => Change::Immediate.new(120),
       4 => Change::Gradual.linear(60,2),

data/spec/notation/conversion/score_converter_spec.rb

@@ -74,32 +74,32 @@ describe ScoreConverter::Measured do
   
   describe '#convert_program' do
     before :each do
-      @prog = Program.new([0...4,2...5])
+      @prog = [0...4,2...5]
       @score = Score::Measured.new(FOUR_FOUR, 120, program: @prog)
       @converter = ScoreConverter::Measured.new(@score,200)
     end
     
-    it 'shuld return Program with same number of segments' do
+    it 'shuld return array with same size' do
       prog = @converter.convert_program
-      prog.should be_a Program
-      prog.segments.size.should eq(@score.program.segments.size)
+      prog.should be_a Array
+      prog.size.should eq(@score.program.size)
     end
   
     it 'should convert program segments offsets from measure-based to note-based' do
       prog = ScoreConverter::Measured.new(@score,200).convert_program
-      prog.segments.size.should eq(2)
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(8)
-      prog.segments[1].first.should eq(4)
-      prog.segments[1].last.should eq(10)
+      prog.size.should eq(2)
+      prog[0].first.should eq(0)
+      prog[0].last.should eq(8)
+      prog[1].first.should eq(4)
+      prog[1].last.should eq(10)
       
       @score.start_meter = THREE_FOUR
       prog = ScoreConverter::Measured.new(@score,200).convert_program
-      prog.segments.size.should eq(2)
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(6)
-      prog.segments[1].first.should eq(3)
-      prog.segments[1].last.should eq(7.5)
+      prog.size.should eq(2)
+      prog[0].first.should eq(0)
+      prog[0].last.should eq(6)
+      prog[1].first.should eq(3)
+      prog[1].last.should eq(7.5)
     end
   end
   
@@ -111,7 +111,7 @@ describe ScoreConverter::Measured do
     end
   
     it 'should use output from convert_program' do
-      prog = Program.new([0...4,2...5])
+      prog =[0...4,2...5]
       score = Score::Measured.new(FOUR_FOUR, 120, program: prog)
       converter = ScoreConverter::Measured.new(score,200)
       nscore = converter.convert_score
@@ -197,23 +197,23 @@ describe ScoreConverter::Unmeasured do
   
   describe '#convert_program' do
     before :each do
-      @prog = Program.new([0...4,2...5])
+      @prog = [0...4,2...5]
       @score = Score::Unmeasured.new(120, program: @prog)
       @converter = ScoreConverter::Unmeasured.new(@score,200)
       @prog2 = @converter.convert_program
     end
     
-    it 'should return Program with same number of segments' do
-      @prog2.should be_a Program
-      @prog2.segments.size.should eq(@prog.segments.size)
+    it 'should return array with same size' do
+      @prog2.should be_a Array
+      @prog2.size.should eq(@prog.size)
     end
   
     it 'should convert program segments offsets from note-based to time-based' do
       prog = @prog2
-      prog.segments[0].first.should eq(0)
-      prog.segments[0].last.should eq(8)
-      prog.segments[1].first.should eq(4)
-      prog.segments[1].last.should eq(10)
+      prog[0].first.should eq(0)
+      prog[0].last.should eq(8)
+      prog[1].first.should eq(4)
+      prog[1].last.should eq(10)
     end
   end
   
@@ -225,7 +225,7 @@ describe ScoreConverter::Unmeasured do
     end
   
     it 'should use output from convert_program' do
-      prog = Program.new([0...4,2...5])
+      prog = [0...4,2...5]
       score = Score::Unmeasured.new(120, program: prog)
       converter = ScoreConverter::Unmeasured.new(score,200)
       nscore = converter.convert_score

data/spec/notation/model/link_spec.rb

@@ -1,83 +1,85 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-{
-  Link::Glissando => Link::Portamento,
-  Link::Portamento => Link::Glissando,
-  Link::Slur => Link::Legato,
-  Link::Legato => Link::Slur
-}.each do |klass,klass2|
+[
+  [Link::Glissando, Link::Portamento, LINK_SYMBOLS[Links::GLISSANDO]],
+  [Link::Portamento, Link::Glissando, LINK_SYMBOLS[Links::PORTAMENTO]],
+].each do |klass,klass2,link_symbol|
   describe klass do
+    before :all do
+      @tgt_pitch = C2
+      @obj = klass.new(@tgt_pitch)
+    end
+
     describe '#initialize' do
       it 'should assign the given pitch to :target_pitch' do
-        klass.new(C2).target_pitch.should eq(C2)
+        @obj.target_pitch.should eq(@tgt_pitch)
       end
     end
     
     describe '#==' do
       it 'should return true if two links have the same target pitch' do
-        klass.new(C2).should eq(klass.new(C2))
+        @obj.should eq(klass.new(@tgt_pitch))
       end
       
       it 'should return false if two links do not have the same target pitch' do
-        klass.new(C2).should_not eq(klass.new(F5))
+        @obj.should_not eq(klass.new(@tgt_pitch.transpose(1)))
       end
       
       it 'should return false if the link type is different' do
-        klass.new(C2).should_not eq(klass2.new(C2))
+        @obj.should_not eq(klass2.new(@tgt_pitch))
       end
     end
     
     describe '#clone' do
       it 'should return a link equal to original' do
-        l = klass.new(C4)
-        l.clone.should eq l
+        @obj.clone.should eq @obj
       end
     end
     
     describe '#to_yaml' do
       it 'should produce YAML that can be loaded' do
-        l = klass.new(C5)
-        YAML.load(l.to_yaml).should eq l
+        YAML.load(@obj.to_yaml).should eq @obj
       end
     end
     
     describe '#to_s' do
       it 'should produce string that include link char and target pitch str' do
-        l = klass.new(C3)
-        l.to_s.should eq(l.link_char + "C3")
+        @obj.to_s.should eq(link_symbol + @tgt_pitch.to_s)
       end
     end
   end
 end
 
 describe Link::Tie do
+  before :all do
+    @obj = Link::Tie.new
+  end
+
   describe '#==' do
     it 'should return true if another Tie object is given' do
-      Link::Tie.new.should eq(Link::Tie.new)
+      @obj.should eq(Link::Tie.new)
     end
     
-    it 'should return false if a non-Tie object is given' do
-      Link::Tie.new.should_not eq(Link::Portamento.new(C2))
+    it 'should return false if an object of another class is given' do
+      @obj.should_not eq(5)
     end
   end
   
   describe '#clone' do
     it 'should return a link equal to original' do
-      l = Link::Tie.new
-      l.clone.should eq l
+      @obj.clone.should eq @obj
     end
   end
   
   describe '#to_yaml' do
     it 'should produce YAML that can be loaded' do
-      l = Link::Tie.new
-      YAML.load(l.to_yaml).should eq l
+      YAML.load(@obj.to_yaml).should eq @obj
     end
   end
   
   describe '#to_s' do
-    it 'should return =' do
-      Link::Tie.new.to_s.should eq("=")
+    it "should return #{LINK_SYMBOLS[Links::TIE]}" do
+      @obj.to_s.should eq(LINK_SYMBOLS[Links::TIE])
     end
   end
 end