bioinform 0.0.1 → 0.1.0

data/spec/data_models/pm_spec.rb

@@ -0,0 +1,369 @@
+require 'spec_helper'
+require 'bioinform/data_models/pm'
+
+module Bioinform
+  describe PM do 
+    include PM::Parser::Helpers
+    
+    describe '#valid?' do
+      it 'should be true iff an argument is an array of arrays of 4 numerics in a column' do
+        PM.new.instance_eval{@matrix = [[1,2,3,4],[1,4,5,6.5]]; self }.valid?.should be_true
+        PM.new.instance_eval{@matrix = {A: [1,1], C: [2,4], G: [3,5], T: [4, 6.5]}; self }.valid?.should be_false
+        PM.new.instance_eval{@matrix = [{A:1,C:2,G:3,T:4},{A:1,C:4,G:5,T: 6.5}]; self }.valid?.should be_false
+        PM.new.instance_eval{@matrix = [[1,2,3,4],[1,4,6.5]]; self }.valid?.should be_false
+        PM.new.instance_eval{@matrix = [[1,2,3],[1,4,6.5]]; self }.valid?.should be_false
+        PM.new.instance_eval{@matrix = [[1,2,'3','4'],[1,'4','5',6.5]]; self }.valid?.should be_false
+      end
+    end
+    
+    describe '#initialize' do
+      context 'when parser specified' do
+        before :each do
+          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
+          parser_stub :ParserGood, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'Good' }
+          parser_stub :ParserWithIncompleteOutput, true, { name: 'Without `matrix` key' }
+          parser_stub :ParserGoodWithoutName, true, { matrix: [[1,1,1,1],[1,1,1,1]] }
+          parser_stub :ParserWithInvalidMatrix, true, { matrix: [[1,1,1],[1,1,1]] }
+        end
+        after :each do  
+          parser_subclasses_cleanup 
+        end
+        
+        it 'should raise an ArgumentError if parser cannot parse input' do
+          expect{ PM.new('my stub input', ParserBad) }.to raise_error ArgumentError
+        end
+        it 'should raise an ArgumentError if parser output doesn\'t have `matrix` key' do
+          expect{ PM.new('my stub input', ParserWithIncompleteOutput) }.to raise_error ArgumentError
+        end
+        it 'should raise an ArgumentError if parser output has invalid matrix' do
+          expect{ PM.new('my stub input', ParserWithInvalidMatrix) }.to raise_error ArgumentError
+        end
+        
+        context 'when parse was successful' do
+          it 'should load matrix from parser\'s resulting hash' do
+            pm = PM.new('my stub input', ParserGoodWithoutName)
+            pm.matrix.should == [[1,1,1,1],[1,1,1,1]]
+            pm.name.should be_nil
+          end
+          it 'should set other available attributes from parse resulting hash' do
+            pm = PM.new('my stub input', ParserGood)
+            pm.matrix.should == [[1,1,1,1],[1,1,1,1]]
+            pm.name.should == 'Good'
+          end
+        end
+      end
+      
+      context 'when parser not specified' do
+        after :each do
+          parser_subclasses_cleanup 
+        end
+        it 'should raise an ArgumentError if no one parser can parse input' do
+          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
+          expect{ PM.new('my stub input') }.to raise_error ArgumentError
+        end
+        it 'should use first parsed which can parse input' do
+          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
+          parser_stub :ParserGoodFirst, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'GoodFirst' }
+          parser_stub :ParserGoodSecond, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'GoodSecond' }
+          
+          pm = PM.new('my stub input')
+          pm.name.should == 'GoodFirst'
+        end
+      end
+    end
+    
+    describe '#matrix=' do
+      it 'should replace matrix if argument is a valid matrix' do
+        @pm = PM.new()
+        @pm.matrix.should be_nil
+        
+        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @pm.matrix.should == [[1,2,3,4],[1,4,5,6.5]]
+        
+        @pm.matrix = [[1,4,5,6.5], [2,2,2,2]]
+        @pm.matrix.should == [[1,4,5,6.5],[2,2,2,2]]
+      end
+      it 'should raise an exception if argument isn\'t valid matrix' do
+        @pm = PM.new
+        expect{  @pm.matrix = [[1,2,3,4],[1,4,5]]  }.to raise_error
+      end
+    end
+    
+    describe '#to_s' do
+      before :each do
+        @pm = PM.new
+        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+      end
+      it 'should return string with single-tabulated multiline matrix' do
+        @pm.to_s.should == "1\t2\t3\t4\n1\t4\t5\t6.5"
+      end
+      it 'should return positions in rows, letters in cols' do
+        @pm.to_s.split("\n").size.should == 2
+        @pm.to_s.split("\n").map{|pos| pos.split.size}.all?{|sz| sz==4}.should be_true
+      end
+      context 'with name specified' do
+        before :each do
+          @pm.name = 'Stub name'
+        end
+        it 'should return a string with a name and a matrix from the next line' do
+          @pm.to_s.should == "Stub name\n1\t2\t3\t4\n1\t4\t5\t6.5"
+        end
+        it 'should not return a name if argument is set to false' do
+          @pm.to_s(false).should == "1\t2\t3\t4\n1\t4\t5\t6.5"
+        end
+      end
+    end
+    
+    describe '#pretty_string' do
+      it 'should return a string formatted with spaces'
+      it 'should contain first string of ACGT letters'
+      context 'with name specified' do
+        it 'should contain name if parameter isn\'t false'
+      end
+      context 'without name specified' do
+        it 'should not contain name'
+      end
+    end
+    
+    describe '#size' do
+      it 'should return number of positions' do
+        @pm = PM.new
+        @pm.matrix = [[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
+        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @hsh = @pm.to_hash
+      end
+      it 'should return a hash with keys A, C, G, T' do
+        @hsh.should be_kind_of Hash
+        @hsh.keys.sort.should == %w{A C G T}
+      end
+      it 'should contain matrix elements of corresponding letter' do
+        @hsh['A'].should == [1, 1]
+        @hsh['C'].should == [2, 4]
+        @hsh['G'].should == [3, 5]
+        @hsh['T'].should == [4, 6.5]
+      end
+      it 'should be accessible both by name and symbol (e.g. pm.to_hash[:A] or pm.to_hash[\'A\'] is the same)' do
+        @hsh['A'].should == @hsh[:A]
+        @hsh['C'].should == @hsh[:C]
+        @hsh['G'].should == @hsh[:G]
+        @hsh['T'].should == @hsh[:T]
+      end
+    end
+    
+    describe '#background' do
+      before :each do
+        @pm = PM.new
+        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+      end
+      context 'when none arguments passed' do
+        context 'when pm just created' do
+          it 'should be [1,1,1,1]' do
+            @pm.background.should == [1,1,1,1]
+          end
+        end
+        it 'should return background' do
+          @pm.instance_eval { @background = [0.2, 0.3, 0.3, 0.2] }
+          @pm.background.should == [0.2, 0.3, 0.3, 0.2]
+        end
+      end
+      context 'when one argument passed' do
+        it 'should set background' do
+          @pm.background([0.2,0.3,0.3,0.2])
+          @pm.background.should == [0.2, 0.3, 0.3, 0.2]
+        end
+      end
+      context 'when more than one argument passed' do
+        it 'should raise an ArgumentError' do
+          expect { @pm.background(:first, :second, :third) }.to raise_error ArgumentError
+        end
+      end
+    end
+    
+    describe '#reverse_complement!' do
+      before :each do
+        @pm = PM.new
+        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+      end
+      it 'should return pm object itself' do
+        @pm.reverse_complement!.should be_equal(@pm)
+      end
+      it 'should reverse matrix rows and columns' do
+        @pm.reverse_complement!
+        @pm.matrix.should == [[6.5, 5, 4, 1], [4, 3, 2, 1]]
+      end
+    end
+    
+    describe '#left_augment!' do
+      before :each do
+        @pm = PM.new
+        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+      end
+      it 'should return pm object itself' do
+        @pm.left_augment!(2).should be_equal(@pm)
+      end
+      it 'should add number of zero columns from the left' do
+        @pm.left_augment!(2)
+        @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
+        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+      end
+      it 'should return pm object itself' do
+        @pm.right_augment!(2).should be_equal(@pm)
+      end
+      it 'should add number of zero columns from the right' do
+        @pm.right_augment!(2)
+        @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
+        @pm.matrix = [[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
+        @pm.matrix = [[1.3, 2.0, 3.2, 4.9], [6.51, 6.5, 3.25, 4.633]]
+      end
+      it 'should return pm object itself' do
+        @pm.discrete!(10).should be_equal(@pm)
+      end
+      context 'rate is 1' do
+        it 'should discrete each element of matrix' do
+          @pm.discrete!(1)
+          @pm.matrix.should == [[2, 2, 4, 5], [7, 7, 4, 5]]
+        end
+      end
+      it 'should discrete each element of matrix multiplied by rate' do
+        @pm.discrete!(10)
+        @pm.matrix.should == [[13, 20, 32, 49], [66, 65, 33, 47]]
+      end
+    end
+    
+    describe '#background_sum' do
+      before :each do
+        @pm = PM.new
+        @pm.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]]
+      end
+      context 'when background is [1,1,1,1]' do
+        it 'should be 4' do
+          @pm.background_sum.should == 4
+        end
+      end
+      it 'should be sum of background' do
+        @pm.background( [0.2, 0.3, 0.3, 0.2] )
+        @pm.background_sum.should == 1.0
+      end
+    end
+    
+    describe '#vocabulary_volume' do
+      before :each do
+        @pm_2_positions = PM.new
+        @pm_2_positions.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]]
+        @pm_3_positions = PM.new
+        @pm_3_positions.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6], [1, 2, 3, 4]]
+      end
+      context 'when background is [1,1,1,1]' do
+        it 'should be equal to number of words' do
+          @pm_2_positions.vocabulary_volume.should == 4**2
+          @pm_3_positions.vocabulary_volume.should == 4**3
+        end
+      end
+      context 'when background is normalized probabilities' do
+        it 'should be 1.0' do
+          @pm_2_positions.background( [0.2, 0.3, 0.3, 0.2] )
+          @pm_2_positions.background_sum.should == 1.0
+          
+          @pm_3_positions.background( [0.2, 0.3, 0.3, 0.2] )
+          @pm_3_positions.background_sum.should == 1.0
+        end
+      end
+    end
+    
+    describe '#best_score' do
+      it 'should be equal to best score' do
+        @pm = PM.new
+        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm.best_score.should == 4.9 + 7.13 + (-1.0)
+      end
+    end
+    describe '#worst_score' do
+      it 'should be equal to worst score' do
+        @pm = PM.new
+        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm.worst_score.should == 1.3 + 3.25 + (-1.5)
+      end
+    end
+    
+    describe '#best_suffix' do
+      it 'should be an array of best suffices from start of string and to empty suffix inclusive' do
+        @pm = PM.new
+        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm.best_suffix.should == [(4.9 + 7.13 - 1.0), (7.13 - 1.0), (-1.0), (0.0) ]
+      end
+    end
+    describe '#worst_suffix' do
+      it 'should be an array of worst suffices from start of string and to empty suffix inclusive' do
+        @pm = PM.new
+        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm.worst_suffix.should == [(1.3 + 3.25 - 1.5), (3.25 - 1.5), (- 1.5), (0.0) ]
+      end
+    end
+
+    [:shift_to_zero, :reverse_complement].each do |meth|
+      describe "nonbang method #{meth}" do
+        before :each do
+          @pm = PM.new
+          @pm.matrix =   [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+          @pm_2 = PM.new
+          @pm_2.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        end
+        it 'should return copy of object not object itself' do
+          @pm.send(meth).should_not be_equal @pm
+        end
+        it 'should == to bang-method' do
+          @pm.send(meth).to_s.should == @pm_2.send("#{meth}!").to_s
+        end
+      end
+    end
+    
+    [:discrete , :left_augment, :right_augment].each do |meth|
+      describe "nonbang method #{meth}" do
+        before :each do
+          @pm = PM.new
+          @pm.matrix =   [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+          @pm_2 = PM.new
+          @pm_2.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        end
+        it 'should return copy of object not object itself' do
+          @pm.send(meth, 2).should_not be_equal @pm
+        end
+        it 'should == to bang-method' do
+          @pm.send(meth, 2).to_s.should == @pm_2.send("#{meth}!", 2).to_s
+        end
+      end
+    end
+  end
+end

data/spec/data_models/pwm_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'bioinform/data_models/pwm'
+
+module Bioinform
+  describe PWM do
+    describe '#score_mean' do
+      it 'should be equal to a mean score of pwm' do
+        pwm = PWM.new
+        pwm.matrix = [[1,2,1,2],[4,6,8,6],[2,2,2,2]]
+        pwm.score_mean.should == 1.5 + 6 + 2
+      end
+      it 'should be equal to a mean score of pwm by measure induced from background probability mean' do
+        pwm = PWM.new.background([0.2, 0.3, 0.3, 0.2])
+        pwm.matrix = [[1,2,1,2],[4,6,8,6],[2,2,2,2]]
+        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
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rspec'
+module Bioinform
+  class PM
+    class Parser
+      module Helpers
+        def parser_stub(class_name, can_parse, result)
+          klass = Class.new(PM::Parser) do
+            define_method :can_parse? do can_parse end
+            define_method :parse do result end
+          end
+          #class_levels = class_name.to_s.split('::')
+          #class_levels[0..-2].inject(Object){|klass, level| klass.const_get level}.const_set(class_name, class_levels.last)
+          Bioinform.const_set(class_name.to_s.split('::').last, klass)
+        end
+        def parser_subclasses_cleanup          
+          PM::Parser.subclasses.each do |klass|
+            #class_levels = klass.to_s.split('::')
+            #class_levels[0..-2].inject(Object){|klass, level| klass.const_get level}.const_set(class_name, class_levels.last)
+            
+            Bioinform.send :remove_const, klass.name.split('::').last
+          end
+          PM::Parser.subclasses.clear
+        end
+      end
+    end
+  end
+end

data/spec/support/callable_symbol_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'bioinform/support/callable_symbol'
+
+# TODO: organize and write more correct descriptions
+describe Symbol do
+  describe '#call' do
+    context 'when symbol curries a block' do
+      it 'should pass a block to a corresponding proc' do
+        :map.(&:to_s).to_proc.call([1,2,3]).should == ['1','2','3']
+        [[1,2,3],[4,5,6]].map(&:map.(&:to_s)).should == [['1','2','3'],['4','5','6']]
+        [[1,2,3],[4,5,6]].map(&:map.(&:to_s.(2))).should == [['1','10','11'],['100','101','110']]
+        ['abc','cdef','xy','z','wwww'].select(&:size.() == 4).should == ['cdef', 'wwww']
+        
+        [%w{1 2 3 4 5},%w{6 7 8 9 10}].map(&:join.().length).should == [5,6]  # method chaining
+        ['abc','aaA','AaA','z'].count(&:upcase.().succ == 'AAB').should == 2 # method chaining with ==
+        [[1,2,3]].map(  &:map.(&:to_s.(2)).map(&:to_i)  ).should == [[1,10,11]]  # method chaining with block on initial symbol and on later symbols
+      end
+    end
+  
+    context 'returned object' do
+      
+      it 'should have to_proc method' do
+        expect { :to_s.() }.to respond_to :to_proc
+        expect { :to_s.(2) }.to respond_to :to_proc
+        expect { :to_s.(2) == '110' }.to respond_to :to_proc
+        expect { :to_s.(2).postprocess('arg1','arg2') }.to respond_to :to_proc
+      end
+      
+      context 'corresponding proc' do
+        it 'should call method, corresponding to symbol, on first argument' do
+          stub_obj = double('obj')
+          stub_obj.should_receive(:to_s).exactly(:twice)
+          prc_1 = :to_s.(2).to_proc
+          prc_2 = :to_s.(2).to_proc # When used with &, to_proc can be omitted: it's implicitly casted on call (see other examples)
+          prc_1.call(stub_obj) # These forms are almost equivalent, but second is much more concise
+          stub_obj.tap(&prc_2)
+        end
+        context 'when multiple arguments of call specified' do
+          it 'should call using given arguments' do
+            stub_obj = double('obj')
+            stub_obj.should_receive(:gsub).with('before','after')
+            prc = :gsub.('before','after')
+            stub_obj.tap(&prc)
+          end
+        end
+        context 'when the only argument of call specified' do
+          it 'should call using given argument' do
+            stub_obj = double('obj')
+            stub_obj.should_receive(:to_s).with(2)
+            prc = :to_s.(2)
+            stub_obj.tap(&prc)
+          end
+        end
+        context 'when no arguments given' do
+          it 'should call without any arguments' do
+            stub_obj = double('obj')
+            stub_obj.should_receive(:to_s).with()
+            prc = :to_s.()
+            stub_obj.tap(&prc)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/spec/support/collect_hash_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'bioinform/support/collect_hash'
+
+describe Enumerable do
+  # %w{A C G T}.collect_hash{|k| [k*2, k*3] }
+  # # ==> {"AA" => "AAA", "CC" => "CCC", "GG" => "GGG", "TT" => "TTT"}
+  context '#collect_hash' do
+    it 'should take a block and create a hash from collected [k,v] pairs' do
+      %w{A C G T}.collect_hash{|k| [k*2, k*3] }.should == {"AA" => "AAA", "CC" => "CCC", "GG" => "GGG", "TT" => "TTT"}
+    end
+    it 'should create a hash from yielded [k,v] pairs if block not given' do
+      %w{A C G T}.each_with_index.collect_hash.should == {"A" => 0, "C" => 1, "G" => 2, "T" => 3}
+    end
+  end
+end

data/spec/support/curry_except_self_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'bioinform/support/curry_except_self'
+
+describe Proc do
+  describe '#curry_except_self' do
+    it 'should return proc'
+    it 'should behave like a proc where all arguments except first are curried'
+  end
+end

data/spec/support/delete_many_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'bioinform/support/delete_many'
+
+describe Array do
+  before :each do 
+    @arr = %w{a b c d e f g h i j b b}
+  end
+  describe '#delete_at_many' do
+    it 'should delete elements at specified indices when indices in ascending order' do
+      @arr.delete_at_many(1,3,7)
+      @arr.should == %w{a c e f g i j b b}
+    end
+    it 'should delete elements at specified indices when indices in descending order' do
+      @arr.delete_at_many(7,3,1)
+      @arr.should == %w{a c e f g i j b b}
+    end
+    it 'should delete elements at specified indices when indices in arbitrary order' do
+      @arr.delete_at_many(3,1,7)
+      @arr.should == %w{a c e f g i j b b}
+    end
+    it 'should delete at each index once' do
+      @arr.delete_at_many(0,0,0,2,0)
+      @arr.should == %w{b d e f g h i j b b}
+    end
+  end
+  describe '#delete_many' do
+    it 'should delete multiple elements with specified values' do
+      @arr.delete_many('b', 'd', 'h', 'b')
+      @arr.should == %w{a c e f g i j}
+    end
+  end
+end
+
+describe Hash do
+  before :each do 
+    @arr = {A: 3, T: 6, G: 4, C: 5}
+  end
+  describe '#delete_many' do
+    it 'should delete specified keys' do
+      @arr.delete_many(:T, :C, :F, :T, :T)
+      @arr.should == {A: 3, G: 4}
+    end
+  end
+end

data/spec/support/has_keys_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'bioinform/support/has_keys'
+
+describe Hash do
+  describe '#has_all_keys?' do
+    it 'should be true if all given keys are at place' do
+      {a: 3, b: 6, c: 7, d: 13}.has_all_keys?(:a, :c).should be_true
+    end
+    
+    it 'should be false if any given of keys is missing' do
+      {a: 3, b: 6, c: 7, d: 13}.has_all_keys?(:a, :x).should be_false
+    end
+  end
+  
+  describe '#has_any_key?' do
+    it 'should be true if any of given keys is at place' do
+      {a: 3, b: 6, c: 7, d: 13}.has_any_key?(:a, :x).should be_true
+    end
+    
+    it 'should be false if no one of given is missing' do
+      {a: 3, b: 6, c: 7, d: 13}.has_any_key?(:x, :y).should be_false
+    end
+  end
+  
+  describe '#has_none_key?' do
+    it 'should be true if all given keys are missing' do
+      {a: 3, b: 6, c: 7, d: 13}.has_none_key?(:x, :y).should be_true
+    end
+    
+    it 'should be false if any of given keys is at place' do
+      {a: 3, b: 6, c: 7, d: 13}.has_none_key?(:a, :y).should be_false
+    end
+  end
+  
+  describe '#has_one_key?' do
+    it 'should be true if one of given keys is present' do
+      {a: 3, b: 6, c: 7, d: 13}.has_one_key?(:x, :a).should be_true
+    end
+    
+    it 'should be false if many of given keys are present' do
+      {a: 3, b: 6, c: 7, d: 13}.has_one_key?(:a, :c).should be_false
+    end
+    
+    it 'should be false if none of given keys is at place' do
+      {a: 3, b: 6, c: 7, d: 13}.has_one_key?(:x, :y).should be_false
+    end
+  end
+end

data/spec/support/inverf_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'bioinform/support/inverf'
+
+describe 'Math#inverf' do
+  it 'should be erf(inverf(x)) == x' do
+    rng = (-0.9..0.9).step(0.1)
+    arr = rng.to_a
+    arr2 = rng.map{|x| Math.inverf(x)}.map{|x| Math.erf(x)}
+    delta = arr.each_index.map{|i| (arr[i] - arr2[i]).abs }
+    delta.each{|el| el.should <= 0.001}
+  end
+  it 'should be erf(inverf(x)) == x' do
+    rng = (-5..5).step(1)
+    arr = rng.to_a
+    arr2 = rng.map{|x| Math.erf(x)}.map{|x| Math.inverf(x)}
+    delta = arr.each_index.map{|i| (arr[i] - arr2[i]).abs }
+    delta.each{|el| el.should <= 0.01}
+  end
+end

data/spec/support/multiline_squish_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'bioinform/support/multiline_squish'
+
+describe String do
+  describe '#multiline_squish' do
+    it 'should replace multiple spaces with one space'
+    it 'should replace tabs with a space'
+    it 'should replace \r\n with \n'
+    it 'should preserve rows pagination'
+  end
+end

data/spec/support/partial_sums_spec.rb

@@ -0,0 +1,9 @@
+describe 'Array#partial_sums' do
+  it 'should return an array of the same size with partial sums of elements 0..ind inclusive with float elements' do
+    [2,3,4,5].partial_sums.should == [2, 5, 9, 14]
+    [2,3,4,5].partial_sums.last.should be_kind_of(Float)
+  end
+  it 'should start counting from argument when it\'s given' do
+    [2,3,4,5].partial_sums(100).should == [102,105,109,114]
+  end
+end