bioinform 0.1.6 → 0.1.7

data/spec/data_models/pcm_spec.rb

@@ -9,10 +9,10 @@ module Bioinform
         PCM.new([[1, 2.3, 3.2, 1],[4.4, 0.1, 1, 2]]).count.should == 7.5
       end
     end
-    
+
     describe '#to_pwm' do
       it 'should return PWM' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm.should be_kind_of(PWM) 
+        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm.should be_kind_of(PWM)
       end
       it 'should make transformation: el --> log( (el + p_i*pseudocount) / (p_i*(count + pseudocount)) )' do
         PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm(1).matrix.map{|line|line.map{|el| el.round(3)}}.should  == [[-0.47, 0.118, 0.486, -0.47],[0.754, -2.079, -0.47, 0.118]]
@@ -26,10 +26,10 @@ module Bioinform
         PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: 'Stub name').to_pwm.name.should == 'Stub name'
       end
     end
-    
+
     describe '#to_ppm' do
       it 'should return PPM' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_ppm.should be_kind_of(PPM) 
+        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_ppm.should be_kind_of(PPM)
       end
       it 'should make transformation el --> el / count' do
         PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_ppm.should == PPM.new([[1.0/7, 2.0/7, 3.0/7, 1.0/7],[4.0/7, 0.0/7, 1.0/7, 2.0/7]])
@@ -40,6 +40,6 @@ module Bioinform
       end
     end
 
-    
+
   end
 end

data/spec/data_models/pm_spec.rb

@@ -2,8 +2,127 @@ require 'spec_helper'
 require 'bioinform/data_models/pm'
 
 module Bioinform
-  describe PM do 
+  describe PM do
+    {:to_pcm => PCM, :to_pwm => PWM, :to_ppm => PPM}.each do |converter_method, result_klass|
+      describe "##{converter_method}" do
+        before :each do
+          @collection = Collection.new(name: 'Collection 1')
+          @matrix = [[1,2,3,4],[5,6,7,8]]
+          @name = 'Motif name'
+          @background = [0.2,0.3,0.3,0.2]
+          @tags = [@collection, 'Collection 2']
+          @pm = PM.new(matrix: @matrix, name: @name, background: @background, tags: @tags)
+          @conv_motif = @pm.send converter_method
+        end
+        it "should return an instance of #{result_klass}" do
+          @conv_motif.should be_kind_of(result_klass)
+        end
+        it 'should return have the same matrix, name, background and tags' do
+          @conv_motif.matrix.should == @matrix
+          @conv_motif.name.should == @name
+          @conv_motif.background.should == @background
+          @conv_motif.tags.should == @tags
+        end
+      end
+    end
     
+    describe '#tagged?' do
+      context 'when PM marked with Collection object' do
+        context 'without collection-name' do
+          before :each do
+            @marking_collection = Collection.new
+            @nonmarking_collection = Collection.new
+            @pm = PM.new(matrix:[[1,1,1,1]], name:'Motif name')
+            @pm.mark(@marking_collection)
+          end
+          it 'should be true for marking collection' do
+            @pm.should be_tagged(@marking_collection)
+          end
+          it 'should be false for nonmarking collection' do
+            @pm.should_not be_tagged(@nonmarking_collection)
+          end
+          it 'should be false for nil-name' do
+            @pm.should_not be_tagged(nil)
+          end
+          it 'should be false for any string' do
+            @pm.should_not be_tagged('Another name')
+          end
+        end
+        context 'with collection-name' do
+          before :each do
+            @marking_collection = Collection.new(name: 'Collection name')
+            @nonmarking_collection = Collection.new(name: 'Another name')
+            @pm = PM.new(matrix:[[1,1,1,1]], name:'Motif name')
+            @pm.mark(@marking_collection)
+          end
+          it 'should be true for marking collection' do
+            @pm.should be_tagged(@marking_collection)
+          end
+          it 'should be false for nonmarking collection' do
+            @pm.should_not be_tagged(@nonmarking_collection)
+          end
+          it 'should be true for name of marking collection' do
+            @pm.should be_tagged('Collection name')
+          end
+          it 'should be false for string that is not name of marking collection' do
+            @pm.should_not be_tagged('Another name')
+          end
+        end
+      end
+
+      context 'when PM marked with name' do
+        before :each do
+          @nonmarking_collection = Collection.new(name: 'Another name')
+          @pm = PM.new(matrix:[[1,1,1,1]], name:'Motif name')
+          @pm.mark('Mark name')
+        end
+        it 'should be true for marking name' do
+          @pm.should be_tagged('Mark name')
+        end
+        it 'should be false for string that is not marking name' do
+          @pm.should_not be_tagged('Another name')
+        end
+        it 'should be false for nonmarking collection' do
+          @pm.should_not be_tagged(@nonmarking_collection)
+        end
+      end
+
+      context 'when PM marked with several marks' do
+        before :each do
+          @collection_1 = Collection.new(name: 'First name')
+          @collection_2 = Collection.new(name: 'Second name')
+          @collection_3 = Collection.new(name: 'Nonmarking collection')
+          @pm = PM.new(matrix:[[1,1,1,1]], name:'Motif name')
+          @pm.mark(@collection_1)
+          @pm.mark(@collection_2)
+          @pm.mark('Stringy-name')
+        end
+        it 'should be true for each mark' do
+          @pm.should be_tagged(@collection_1)
+          @pm.should be_tagged(@collection_2)
+          @pm.should be_tagged('Stringy-name')
+        end
+        it 'should be false for not presented marks' do
+          @pm.should_not be_tagged(@collection_3)
+          @pm.should_not be_tagged('Bad stringy-name')
+        end
+      end
+    end
+
+    describe '#==' do
+      it 'should be true iff motifs have the same matrix, background and name' do
+      pm = PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'First motif')
+      pm_eq = PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'First motif')
+      pm_neq_matrix = PM.new(matrix: [[1,2,3,4],[15,16,17,18]], name: 'First motif')
+      pm_neq_name = PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'Second motif')
+      pm_neq_background = PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'First motif').background!([1,2,2,1])
+
+      pm.should_not == pm_neq_matrix
+      pm.should_not == pm_neq_name
+      pm.should_not == pm_neq_background
+      pm.should == pm_eq
+      end
+    end
     describe '::valid_matrix?' do
       it 'should be true iff an argument is an array of arrays of 4 numerics in a column' do
         PM.valid_matrix?( [[1,2,3,4],[1,4,5,6.5]] ).should be_true
@@ -14,7 +133,7 @@ module Bioinform
         PM.valid_matrix?( [[1,2,'3','4'],[1,'4','5',6.5]] ).should be_false
       end
     end
-    
+
     describe '#to_s' do
       before :each do
         @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
@@ -43,7 +162,7 @@ module Bioinform
         end
       end
     end
-    
+
     describe '#pretty_string' do
       it 'should format string with 7-chars fields' do
         PM.new( [[1,2,3,4],[5,6,7,8]] ).pretty_string.should == "   A      C      G      T   \n   1.0    2.0    3.0    4.0\n   5.0    6.0    7.0    8.0"
@@ -57,7 +176,7 @@ module Bioinform
       it 'should round floats upto 3 digits' do
         PM.new( [[1.1,2.22,3.333,4.4444],[5.5,6.66,7.777,8.8888]] ).pretty_string.should match(/1.1 +2.22 +3.333 +4.444 *\n *5.5 +6.66 +7.777 +8.889/)
       end
-      
+
       context 'with name specified' do
         before :each do
           @pm = PM.new( [[1.1,2.22,3.333,4.4444],[5.5,6.66,7.777,8.8888]] )
@@ -86,14 +205,14 @@ module Bioinform
         end
       end
     end
-    
+
     describe '#size' do
       it 'should return number of positions' do
         @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
         @pm.size.should == 2
       end
     end
-    
+
     describe '#to_hash' do
       before :each do
         @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
@@ -116,7 +235,7 @@ module Bioinform
         @hsh['T'].should == @hsh[:T]
       end
     end
-    
+
     describe '#background' do
       before :each do
         @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
@@ -144,7 +263,7 @@ module Bioinform
         end
       end
     end
-    
+
     describe '#reverse_complement!' do
       before :each do
         @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
@@ -157,7 +276,7 @@ module Bioinform
         @pm.matrix.should == [[6.5, 5, 4, 1], [4, 3, 2, 1]]
       end
     end
-    
+
     describe '#left_augment!' do
       before :each do
         @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
@@ -170,7 +289,7 @@ module Bioinform
         @pm.matrix.should == [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [1, 2, 3, 4], [1, 4, 5, 6.5]]
       end
     end
-    
+
     describe '#right_augment!' do
       before :each do
         @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
@@ -183,20 +302,7 @@ module Bioinform
         @pm.matrix.should == [[1, 2, 3, 4], [1, 4, 5, 6.5], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
       end
     end
-    
-    describe '#shift_to_zero!' do
-      before :each do
-        @pm = PM.new( [[1, 2, 3, 4], [5, 6.5, 3, 4]] )
-      end
-      it 'should return pm object itself' do
-        @pm.shift_to_zero!.should be_equal(@pm)
-      end
-      it 'should make shift each column' do
-        @pm.shift_to_zero!
-        @pm.matrix.should == [[0, 1, 2, 3], [2, 3.5, 0, 1]]
-      end
-    end
-    
+
     describe '#discrete!' do
       before :each do
         @pm = PM.new( [[1.3, 2.0, 3.2, 4.9], [6.51, 6.5, 3.25, 4.633]] )
@@ -215,7 +321,7 @@ module Bioinform
         @pm.matrix.should == [[13, 20, 32, 49], [66, 65, 33, 47]]
       end
     end
-    
+
     describe '#vocabulary_volume' do
       before :each do
         @pm_2_positions = PM.new( [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]] )
@@ -231,13 +337,13 @@ module Bioinform
         it 'should be 1.0' do
           @pm_2_positions.background( [0.2, 0.3, 0.3, 0.2] )
           @pm_2_positions.vocabulary_volume.should == 1.0
-          
+
           @pm_3_positions.background( [0.2, 0.3, 0.3, 0.2] )
           @pm_3_positions.vocabulary_volume.should == 1.0
         end
       end
     end
-    
+
     describe '#best_score' do
       it 'should be equal to best score' do
         @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
@@ -250,7 +356,7 @@ module Bioinform
         @pm.worst_score.should == 1.3 + 3.25 + (-1.5)
       end
     end
-    
+
     describe '#best_suffix' do
       it 'should return maximal score of suffices from i-th position inclusively i.e. [i..end]' do
         @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
@@ -276,7 +382,7 @@ module Bioinform
       end
     end
 
-    [:shift_to_zero, :reverse_complement].each do |meth|
+    [:reverse_complement].each do |meth|
       describe "nonbang method #{meth}" do
         before :each do
           @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
@@ -290,7 +396,7 @@ module Bioinform
         end
       end
     end
-    
+
     [:discrete , :left_augment, :right_augment].each do |meth|
       describe "nonbang method #{meth}" do
         before :each do

data/spec/data_models/ppm_spec.rb

@@ -3,6 +3,6 @@ require 'bioinform/data_models/pcm'
 
 module Bioinform
   describe PPM do
-    
+
   end
 end

data/spec/data_models/pwm_spec.rb

@@ -13,10 +13,10 @@ module Bioinform
         pwm.score_mean.should == ((0.2*1+0.3*2+0.3*1+0.2*2) + (0.2*4+0.3*6+0.3*8+0.2*6) + (0.2*2+0.3*2+0.3*2+0.2*2)) / (0.2+0.3+0.3+0.2)
       end
     end
-    
+
     describe '#score_variance' do
     end
-    
+
     describe '#gauss_estimation' do
     end
 

data/spec/parsers/parser_spec.rb

@@ -14,7 +14,7 @@ module Bioinform
         Parser.new([1,2,3,4]).parse.should == Parser.new([[1,2,3,4]]).parse
       end
     end
-    
+
     context '::parse!' do
       it 'should behave like Parser.new(input).parse!' do
         Parser.parse!([1,2,3,4],[5,6,7,8]).should  == Parser.new([1,2,3,4],[5,6,7,8]).parse!
@@ -27,7 +27,7 @@ module Bioinform
         Parser.parse([1,2,3],[4,5,6]).should be_nil
       end
     end
-    
+
     context '::choose' do
       it 'should create parser of appropriate type' do
         Parser.choose([[1,2,3,4],[5,6,7,8]]).should be_kind_of(Parser)
@@ -37,16 +37,16 @@ module Bioinform
         Parser.choose("1 2 3 4\n5 6 7 8").should be_kind_of(StringParser)
         Parser.choose("1 2 3 4\n5 6 7 8").input.should == "1 2 3 4\n5 6 7 8"
       end
-      
+
     end
 
-    
+
     context '::normalize_hash_keys' do
       it 'should convert both symbolic and string keys, in both upcase and downcase to symbolic upcases' do
         Parser.normalize_hash_keys( {a: 1, C: 2, 'g' => 3, 'T' => 4} ).should == {A: 1, C: 2, G: 3, T: 4}
       end
     end
-    
+
     context '::need_transpose?' do
       it 'should point whether matrix have positions(need not be transposed -- false) or letters(true) as first index' do
         Parser.need_tranpose?([[1,3,5,7], [2,4,6,8]]).should be_false
@@ -82,7 +82,7 @@ module Bioinform
         Parser.try_convert_to_array( {:A => [1,2,3], :c => [2,3,4], 'g' => [3,4,5], 'T' => [4,5,6]} ).should == [[1,2,3],[2,3,4],[3,4,5],[4,5,6]].transpose
       end
     end
-  
+
     context '#parse' do
       it 'should give the same result as #parse!' do
         parser = Parser.new('stub parser')
@@ -95,61 +95,61 @@ module Bioinform
         parser.parse.should be_nil
       end
     end
-    
+
     good_cases = {
-      'Array Nx4' => {input: [[0,1,2,3],[10,11,12,13]], 
+      'Array Nx4' => {input: [[0,1,2,3],[10,11,12,13]],
                         matrix: [[0,1,2,3],[10,11,12,13]] },
-                        
+
       'Array 4xN' => {input: [[0,10],[1,11],[2,12],[3,13]],
                         matrix: [[0,1,2,3],[10,11,12,13]] },
-                        
-      'Hash A,C,G,T => Arrays' => { input: {:A => [0,10], :c => [1,11],'g' => [2,12],'T' => [3,13]}, 
+
+      'Hash A,C,G,T => Arrays' => { input: {:A => [0,10], :c => [1,11],'g' => [2,12],'T' => [3,13]},
                                     matrix: [[0,1,2,3],[10,11,12,13]] },
-                                    
+
       'Hash array of hashes' => { input: [{:A => 0,:c => 1,'g' => 2,'T' => 3}, {:A => 10,:c => 11,'g' => 12,'T' => 13}],
                                   matrix: [[0,1,2,3],[10,11,12,13]] },
-                                  
+
       'Array 4x4 (rows treated as positions, columns are treated as letter)' => { input: [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]],
                                                                                   matrix: [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]] },
-                                                                                  
+
       'Hash A,C,G,T => 4-Arrays' => { input: {:A => [0,10,100,1000], :c => [1,11,101,1001],'g' => [2,12,102,1002],'T' => [3,13,103,1003]},
                                       matrix: [[0,1,2,3],[10,11,12,13],[100,101,102,103],[1000,1001,1002,1003]] },
-                                      
+
       '4-Arrays of A,C,G,T hashes' => { input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
                                                 {:A => 10, :c => 11, 'g' => 12, 'T' => 13},
                                                 {:A => 100, :c => 101, 'g' => 102, 'T' => 103},
                                                 {:A => 1000, :c => 1001, 'g' => 1002, 'T' => 1003}],
                                         matrix: [[0,1,2,3],[10,11,12,13],[100,101,102,103],[1000,1001,1002,1003]] }
     }
-    
+
     bad_cases = {
       'Nil object on input' => {input: nil},
-      
+
       'Empty array on input' => {input: []},
-    
+
       'Different sizes of row arrays' => {input: [[1,2,3,4],[5,6,7,8,9]] },
-      
+
       'Different sizes of column arrays' => {input: [[0,10],[1,11],[2,12],[3]] },
-      
+
       'No one dimension have size 4' => {input: [[0,1,2,3,4],[10,11,12,13,14], [0,1,2,3,4]] },
-      
+
       'Missing keys in column hashes' => {input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
                                                      {:A => 10, :c => 11, 'g' => 12}] },
       'Bad keys in column hashes' => {input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
                                                   {:A => 10, :c => 11, 'g' => 12, :X =>1000}] },
-                                                  
+
       'Excessing keys in column hashes' => { input: [{:A => 0,:c => 1,'g' => 2,'T' => 3},
                                                      {:A => 10,:c => 11,'g' => 12,'T' => 13, :X => 1000}] },
 
       'Different sizes of row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12],'T' => [3,13,14]} },
-      
+
       'Missing keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12]} },
-      
+
       'Wrong keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'X' => [2,12]} },
-      
+
       'Excessing keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12], 'T' => [3,12], :X => [4,14]} }
     }
-    
+
     parser_specs(Parser, good_cases, bad_cases)
     context '#parser!' do
       it "should raise an exception on parsing empty list to parser" do