statsample 0.16.0 → 0.17.0

data/lib/statsample/combination.rb

@@ -1,114 +0,0 @@
-module Statsample
-  # Combination class systematically generates all combinations of n elements, taken r at a time.
-  # With rbgsl, GSL::Combination is available for extra speed
-  # == Use:
-  #  comb=Statsample::Combination.new(3,5)
-  #  => #<Statsample::Combination:0x7f6323804e08 @n=5, @d=#<Statsample::Combination::CombinationGsl:0x7f63237ff7f0 @n=5, @k=3, @c=GSL::Combination>, @k=3>
-  #  comb.each{|c| p c }
-  #  [0, 1, 2]
-  #  [0, 1, 3]
-  #  [0, 1, 4]
-  #  [0, 2, 3]
-  #  [0, 2, 4]
-  #  [0, 3, 4]
-  #  [1, 2, 3]
-  #  [1, 2, 4]
-  #  [1, 3, 4]
-  #  [2, 3, 4]
-  # == Reference:
-  # * http://snippets.dzone.com/posts/show/4666
-  #
-  class Combination
-    attr_reader :d
-    def initialize(k,n,only_ruby=false)
-      @k=k
-      @n=n
-      if Statsample.has_gsl? and !only_ruby
-        @d=CombinationGsl.new(@k,@n)
-      else
-        @d=CombinationRuby.new(@k,@n)
-      end
-    end
-    def each
-      reset
-      while a=next_value
-        yield a
-      end
-    end
-    def reset
-        @d.reset
-    end
-    def next_value
-        @d.next_value
-    end
-    class CombinationRuby # :nodoc:
-      attr_reader :data
-      def initialize(k,n)
-        raise "k<=n" if k>n
-        @k=k
-        @n=n
-        reset
-      end
-      def reset
-        @data=[]
-        (0...@k).each {|i| @data[i] = i }
-      end
-      def each
-        reset
-        while a=next_value
-            yield a
-        end
-      end
-      def next_value
-        return false if !@data
-        old_comb=@data.dup
-        i = @k - 1;
-        @data[i]+=1
-        while ((i >= 0) and (@data[i] >= @n - @k + 1 + i)) do
-          i-=1;
-          @data[i]+=1;
-        end
-        
-        if (@data[0] > @n - @k) # Combination (n-k, n-k+1, ..., n) reached */
-          @data=false # No more combinations can be generated 
-        else
-          # comb now looks like (..., x, n, n, n, ..., n).
-          # Turn it into (..., x, x + 1, x + 2, ...) 
-          i = i+1
-          (i...@k).each{ |i1|
-              @data[i1] = @data[i1 - 1] + 1
-          }
-        end
-        return old_comb
-      end
-    end
-    
-    # rb-gsl engine for Combinations
-    class CombinationGsl # :nodoc:
-      def initialize(k,n)
-        require 'gsl'
-        raise "k<=n" if k>n
-        @k=k
-        @n=n
-        reset
-      end
-      def reset
-        @c= ::GSL::Combination.calloc(@n, @k);
-      end
-      def next_value
-        return false if !@c
-        data=@c.data.to_a
-        if @c.next != GSL::SUCCESS
-          @c=false
-        end
-        return data
-      end
-      def each
-        reset
-        begin
-        yield @c.data.to_a
-        end while @c.next == GSL::SUCCESS
-      end
-    end
-  end
-end

data/lib/statsample/permutation.rb

@@ -1,98 +0,0 @@
-module Statsample
-  # Permutation class systematically generates all permutations 
-  # of elements on an array, using Dijkstra algorithm (1997).
-  #
-  # As argument, you could use 
-  # * Number of elements: an array with numbers from 0 to n-1 will be used
-  # * Array: if ordered, you obtain permutations on lexicographic order
-  #          you can repeat elements, if you will.
-  #  
-  #  Use:
-  #  perm=Statsample::Permutation.new(3)
-  #  perm.permutations
-  #  => [[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]
-  #  perm=Statsample::Permutation.new([0,0,1,1])
-  #  => [[0,0,1,1],[0,1,0,1],[0,1,1,0],[1,0,0,1],[1,0,1,0],[1,1,0,0]]
-  #
-  # == Reference:
-  # * http://www.cut-the-knot.org/do_you_know/AllPerm.shtml
-  class Permutation
-    attr_reader :permutation_number
-    def initialize(v)
-      if v.is_a? Numeric
-        @original=(0...v.to_i).to_a
-        @permutation_number=factorial(v)
-      else
-        @original=v
-        calculate_max_iterations_from_array
-      end
-      @n=@original.size
-      reset
-    end
-    def calculate_max_iterations_from_array
-      if @original.respond_to? :frequencies
-        freq=@original.frequencies
-      else
-        freq=@original.to_vector.frequencies
-      end
-      if freq.length==@original.size
-        @permutation_number=factorial(@original.size)
-      else
-        numerator=factorial(@original.size)
-        denominator=freq.inject(1) {|a,v|
-          a*factorial(v[1])
-        }
-        @permutation_number=numerator/denominator
-      end
-    end
-    def factorial (n)
-      (1..n).inject(1){|a,v| a*v}
-    end
-    def reset
-      @iterations=0
-      @data=@original.to_a.dup
-    end
-    def each
-      reset
-      @permutation_number.times do
-        yield next_value
-      end
-    end
-    # Returns permutations
-    def permutations
-      a=Array.new
-      each {|c| a.push(c)}
-      a
-    end
-    def next_value
-      prev=@data.dup
-      i = @n-1
-      while @data[i-1] >= @data[i]
-        #return false if i<0 
-        i=i-1
-      end
-      j=@n
-      while @data[j-1] <= @data[i-1]
-        j=j-1
-      end
-      # swap values at positions (i-1) and (j-1)
-      swap(i-1, j-1);    
-      
-      i+=1
-      j = @n
-      
-      while (i < j)
-        swap(i-1, j-1);
-        i+=1;
-        j-=1;
-        sprintf("%d %d",i,j)
-      end
-      prev
-    end
-    def swap(i,j)
-      tmp=@data[i]
-      @data[i]=@data[j]
-      @data[j]=tmp
-    end
-  end
-end

data/test/test_combination.rb

@@ -1,37 +0,0 @@
-require(File.dirname(__FILE__)+'/helpers_tests.rb')
-
-class StatsampleCombinationTestCase < MiniTest::Unit::TestCase
-  def test_basic
-    k=3
-    n=5
-    expected=[[0,1,2],[0,1,3],[0,1,4],[0,2,3],[0,2,4],[0,3,4],[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
-    comb=Statsample::Combination.new(k,n)
-    a=[]
-    comb.each{|y|
-      a.push(y)
-    }
-    assert_equal(expected,a)
-  end
-  def test_gsl_versus_ruby
-    if Statsample.has_gsl?
-      k=3
-      n=10
-      gsl=Statsample::Combination.new(k,n,false)
-      gsl_array=[]
-      gsl.each{|y|
-        gsl_array.push(y)
-      }
-      rb=Statsample::Combination.new(k,n,true)
-      rb_array=[]
-      rb.each{|y|
-        rb_array.push(y)
-      }
-      assert(gsl.d.is_a?(Statsample::Combination::CombinationGsl))
-      assert(rb.d.is_a?(Statsample::Combination::CombinationRuby))
-
-      assert_equal(rb_array,gsl_array)
-    else
-      skip "Not CombinationRuby vs CombinationGSL (no gsl)"
-    end
-  end
-end

data/test/test_permutation.rb

@@ -1,42 +0,0 @@
-require(File.dirname(__FILE__)+'/helpers_tests.rb')
-
-
-class StatsamplePermutationTestCase < MiniTest::Unit::TestCase
-  context Statsample::Permutation do
-    should "initialize with number" do
-      per1=Statsample::Permutation.new(2)
-      exp1=[[0,1],[1,0]]
-      assert_equal(exp1,per1.permutations)
-      per2=Statsample::Permutation.new(3)
-      exp2=[[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]
-      assert_equal(exp2,per2.permutations)
-    end
-    should "initialize with simple array" do
-      per1=Statsample::Permutation.new(%w{a b})
-      exp1=[['a','b'],['b','a']]
-      assert_equal(exp1,per1.permutations)
-      per2=Statsample::Permutation.new(%w{a b c})
-      exp2=[%w{a b c},%w{a c b},%w{b a c} ,%w{b c a},%w{c a b},%w{c b a}]
-      assert_equal(exp2,per2.permutations)
-    end
-    should "initialize with Statsample::Vector" do
-      per2=Statsample::Permutation.new(%w{a b c}.to_vector)
-      exp2=[%w{a b c},%w{a c b},%w{b a c} ,%w{b c a},%w{c a b},%w{c b a}]
-      assert_equal(exp2, per2.permutations)
-    end
-      
-    should "calculate correct number of total permutations without repetitions" do
-      per1=Statsample::Permutation.new(4)
-      assert_equal(24,per1.permutation_number)      
-    end
-    should "calculate correct number of total permutations with repetitions" do
-      per2=Statsample::Permutation.new([1,1,1,0,0,0])
-      assert_equal(20,per2.permutation_number)
-    end
-    should "initialize with array repeated" do 
-      per1=Statsample::Permutation.new([0,0,1,1])
-      exp1=[[0,0,1,1],[0,1,0,1],[0,1,1,0],[1,0,0,1],[1,0,1,0],[1,1,0,0]]
-      assert_equal(exp1,per1.permutations)
-    end
-  end
-end