statsample 0.3.0

data/test/test_stratified.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'statsample/multiset'
+require 'test/unit'
+
+class StatsampleStratifiedTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+	end
+	def test_mean
+		a=[10,20,30,40,50]
+		b=[110,120,130,140]
+		pop=a+b
+		av=a.to_vector(:scale)
+		bv=b.to_vector(:scale)
+		popv=pop.to_vector(:scale)
+		assert_equal(popv.mean,Statsample::StratifiedSample.mean(av,bv))
+	end
+end

data/test/test_svg_graph.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'tempfile'
+require 'test/unit'
+begin
+	require 'statsample/graph/svggraph'
+class StatsampleSvgGraphTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		@image_path=File.dirname(__FILE__)+"/images"
+		super
+	end
+    def test_histogram
+        if HAS_GSL
+        ar=(1..1000).to_a.collect {|a|
+			rand(10)
+		}.to_vector(:scale)
+        h=ar.histogram([0,2,5,11])
+        file=@image_path+"/svg_histogram_only.svg"
+        graph = Statsample::Graph::SvgHistogram.new({})
+        graph.histogram=h
+        File.open(file,"w") {|f|
+              f.puts(graph.burn)
+        }
+	else
+		puts "Statsample::Graph::SvgHistogram.new not tested (no ruby-gsl)"
+	end
+    end
+    def test_vector
+		file=@image_path+"/gdchart_bar.jpg"
+		ar=[]
+		(1..1000).each {|a|
+			ar.push(rand(10))
+		}
+		vector=ar.to_vector
+        file=@image_path+"/svggraph_default.svg"
+		vector.svggraph_frequencies(file)
+        
+		file=@image_path+"/svggraph_Bar.svg"
+		vector.svggraph_frequencies(file,800,600,SVG::Graph::Bar,:graph_title=>'Bar')
+		assert(File.exists?(file))
+		file=@image_path+"/svggraph_BarHorizontal.svg"
+		vector.svggraph_frequencies(file,800,600,SVG::Graph::BarHorizontalNoOp,:graph_title=>'Horizontal Bar')
+		assert(File.exists?(file))
+		file=@image_path+"/svggraph_Pie.svg"
+		vector.svggraph_frequencies(file,800,600,SVG::Graph::PieNoOp,:graph_title=>'Pie')
+		assert(File.exists?(file))		
+		vector.type=:scale
+		if HAS_GSL
+		file=@image_path+"/svggraph_histogram.svg"		
+		hist=vector.svggraph_histogram(5)
+		File.open(file,"wb") {|fp|
+		fp.write(hist.burn)
+		}
+		assert(File.exists?(file))
+		else
+		puts "Statsample::Vector#svggraph_histogram.new not tested (no ruby-gsl)"
+
+		end
+	end
+end
+rescue LoadError
+	puts "You should install SVG::Graph"
+end

data/test/test_vector.rb

@@ -0,0 +1,265 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleVectorTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+		@c = Statsample::Vector.new([5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99], :nominal)
+		@c.missing_values=[-99]
+	end
+    def test_enumerable
+        val=@c.collect {|v| v}
+        assert_equal(val,[5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99])
+    end
+	def test_missing_values
+		@c.missing_values=[10]
+		assert_equal([-99,-99,1,2,3,4,5,5,5,5,5,6,6,7,8,9], @c.valid_data.sort)
+        assert_equal([5,5,5,5,5,6,6,7,8,9,nil,1,2,3,4,nil,-99,-99], @c.data_with_nils)
+		@c.missing_values=[-99]
+		assert_equal(@c.valid_data.sort,[1,2,3,4,5,5,5,5,5,6,6,7,8,9,10])
+        assert_equal(@c.data_with_nils,[5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,nil,nil])
+		@c.missing_values=[]
+		assert_equal(@c.valid_data.sort,[-99,-99,1,2,3,4,5,5,5,5,5,6,6,7,8,9,10])
+        assert_equal(@c.data_with_nils,[5,5,5,5,5,6,6,7,8,9,10,1,2,3,4,nil,-99,-99])
+        
+	end
+    def test_has_missing_data
+        a=[1,2,3,nil].to_vector
+        assert(a.has_missing_data?)
+        a=[1,2,3,4,10].to_vector
+        assert(!a.has_missing_data?)
+        a.missing_values=[10]
+        assert(a.has_missing_data?)
+    end
+    def test_labeled
+        @c.labels={5=>'FIVE'}
+        assert_equal(["FIVE","FIVE","FIVE","FIVE","FIVE",6,6,7,8,9,10,1,2,3,4,nil,-99, -99],@c.vector_labeled.to_a)
+    end
+    def test_split
+        a = Statsample::Vector.new(["a","a,b","c,d","a,d","d",10,nil],:nominal)
+        assert_equal([%w{a},%w{a b},%w{c d},%w{a d},%w{d},[10],nil], a.splitted)
+    end
+    def test_verify
+        h=@c.verify{|d| !d.nil? and d>0}
+        e={15=>nil,16=>-99,17=>-99}
+        assert_equal(e,h)
+    end
+    def test_split_by_separator
+        a = Statsample::Vector.new(["a","a,b","c,d","a,d",10,nil],:nominal)
+        b=a.split_by_separator(",")
+        assert_kind_of(Hash, b)
+        assert_instance_of(Statsample::Vector,b['a'])
+        assert_instance_of(Statsample::Vector,b['b'])
+        assert_instance_of(Statsample::Vector,b['c'])
+        assert_instance_of(Statsample::Vector,b['d'])
+        assert_instance_of(Statsample::Vector,b[10])
+        assert_equal([1,1,0,1,0,nil],b['a'].to_a)
+        assert_equal([0,1,0,0,0,nil],b['b'].to_a)
+        assert_equal([0,0,1,0,0,nil],b['c'].to_a)
+        assert_equal([0,0,1,1,0,nil],b['d'].to_a)
+        assert_equal([0,0,0,0,1,nil],b[10].to_a)
+        assert_equal({'a'=>3,'b'=>1,'c'=>1,'d'=>2,10=>1}, a.split_by_separator_freq())
+
+        a = Statsample::Vector.new(["a","a*b","c*d","a*d",10,nil],:nominal)
+        b=a.split_by_separator("*")
+        assert_equal([1,1,0,1,0,nil],b['a'].to_a)
+        assert_equal([0,1,0,0,0,nil],b['b'].to_a)
+        assert_equal([0,0,1,0,0,nil],b['c'].to_a)
+        assert_equal([0,0,1,1,0,nil],b['d'].to_a)
+        assert_equal([0,0,0,0,1,nil],b[10].to_a)
+    end
+	def test_types
+		@c.type=:nominal
+		assert_raise NoMethodError do
+			@c.median
+		end
+		@c.type=:ordinal
+		assert_raise NoMethodError do
+			@c.mean
+		end
+	end
+	def test_nominal
+		assert_equal(@c[1],5)
+		assert_equal({ 1=>1,2=>1,3=>1,4=>1,5=>5,6=>2,7=>1,8=>1, 9=>1,10=>1},@c.frequencies)
+		assert_equal({ 1 => 1.quo(15) ,2=>1.quo(15), 3=>1.quo(15),4=>1.quo(15),5=>5.quo(15),6=>2.quo(15),7=>1.quo(15), 8=>1.quo(15), 9=>1.quo(15),10=>1.quo(15)}, @c.proportions)
+        assert_equal(@c.proportion, 1.quo(15))
+        assert_equal(@c.proportion(2), 1.quo(15))
+		assert_equal([1,2,3,4,5,6,7,8,9,10], @c.factors.sort)
+		assert_equal(@c.mode,5)
+		assert_equal(@c.n_valid,15)
+	end
+    def test_equality
+        v1=[1,2,3].to_vector
+        v2=[1,2,3].to_vector
+        assert_equal(v1,v2)
+        v1=[1,2,3].to_vector(:nominal)
+        v2=[1,2,3].to_vector(:ordinal)
+        assert_not_equal(v1,v2)
+        v1=[1,2,3].to_vector()
+        v2=[1,2,3].to_vector()
+        assert_equal(v1,v2)
+    end
+	def test_ordinal
+        @c.type=:ordinal
+		assert_equal(5,@c.median)
+		assert_equal(4,@c.percentil(25))
+		assert_equal(7,@c.percentil(75))
+	end
+	def test_ranked
+		v1=[0.8,1.2,1.2,2.3,18].to_vector(:ordinal)
+		expected=[1,2.5,2.5,4,5].to_vector(:ordinal)
+		assert_equal(expected,v1.ranked)
+	end
+    def test_scale
+        a=Statsample::Vector.new([1,2,3,4,"STRING"], :scale)
+        assert_equal(10, a.sum)
+        i=0
+        factors=a.factors.sort
+        [0,1,2,3,4].each{|v|
+            assert(v==factors[i])
+            assert(v.class==factors[i].class,"#{v} - #{v.class} != #{factors[i]} - #{factors[i].class}")
+            i+=1
+        }
+    end
+    def test_vector_standarized
+        v1=[1,2,3,4,nil].to_vector(:scale)
+        sds=v1.sds
+        expected=[((1-2.5).quo(sds)),((2-2.5).quo(sds)),((3-2.5).quo(sds)),((4-2.5).quo(sds)), nil].to_vector(:scale)
+        vs=v1.vector_standarized
+        assert_equal(expected, vs)
+        assert_equal(0,vs.mean)
+        assert_equal(1,vs.sds)
+    end
+    def test_summary
+        @c.type=:nominal
+        assert_match(/Distribution/, @c.summary())
+        @c.type=:ordinal
+        assert_match(/median/, @c.summary())
+        @c.type=:scale
+        assert_match(/mean/, @c.summary())
+    end
+    def test_add
+        a=Statsample::Vector.new([1,2,3,4,5], :scale)
+        b=Statsample::Vector.new([11,12,13,14,15], :scale)
+        assert_equal([3,4,5,6,7], (a+2).to_a)
+        assert_equal([12,14,16,18,20], (a+b).to_a)
+        assert_raise  ArgumentError do
+			a + @c
+		end
+        assert_raise  TypeError do
+			a+"string"
+		end
+        a=Statsample::Vector.new([nil,1, 2  ,3 ,4 ,5], :scale)
+        b=Statsample::Vector.new([11, 12,nil,13,14,15], :scale)
+        assert_equal([nil,13,nil,16,18,20], (a+b).to_a)
+        assert_equal([nil,13,nil,16,18,20], (a+b.to_a).to_a)
+    end
+    def test_minus
+        a=Statsample::Vector.new([1,2,3,4,5], :scale)
+        b=Statsample::Vector.new([11,12,13,14,15], :scale)
+        assert_equal([-1,0,1,2,3], (a-2).to_a)
+        assert_equal([10,10,10,10,10], (b-a).to_a)
+        assert_raise  ArgumentError do
+			a-@c
+		end
+        assert_raise  TypeError do
+			a-"string"
+		end
+        a=Statsample::Vector.new([nil,1, 2  ,3 ,4 ,5], :scale)
+        b=Statsample::Vector.new([11, 12,nil,13,14,15], :scale)
+        assert_equal([nil,11,nil,10,10,10], (b-a).to_a)
+        assert_equal([nil,11,nil,10,10,10], (b-a.to_a).to_a)
+    end
+	def test_sum_of_squares
+		a=[1,2,3,4,5,6].to_vector(:scale)
+		assert_equal(17.5, a.sum_of_squared_deviation)
+	end
+    def test_samples
+        srand(1)
+        assert_equal(100,@c.sample_with_replacement(100).size)
+        assert_equal(@c.valid_data.to_a.sort, @c.sample_without_replacement(15).sort)
+        assert_raise  ArgumentError do
+			@c.sample_without_replacement(20)
+		end
+        @c.type=:scale
+        srand(1)
+        assert_equal(100, @c.sample_with_replacement(100).size)
+        assert_equal(@c.valid_data.to_a.sort, @c.sample_without_replacement(15).sort)
+        
+    end
+    
+    def test_gsl
+		if HAS_GSL
+			a=Statsample::Vector.new([1,2,3,4,"STRING"], :scale)
+			assert_equal(2,a.mean)
+			assert_equal(a.variance_sample_slow,a.variance_sample)
+			assert_equal(a.standard_deviation_sample_slow,a.sds)
+			assert_equal(a.variance_population_slow,a.variance_population)
+			assert_equal(a.standard_deviation_population_slow,a.standard_deviation_population)
+            assert_nothing_raised do
+                a=[].to_vector(:scale)
+            end
+            a.add(1,false)
+            a.add(2,false)
+            a.set_valid_data
+            assert_equal(3,a.sum)
+            b=[1,2,nil,3,4,5,nil,6].to_vector(:scale)
+            assert_equal(21, b.sum)
+            
+            assert_equal(3.5, b.mean)
+            assert_equal(6,b.gsl.size)
+            # histogram
+            a=[11,12,13,15,21,22,23,32,33].to_vector(:scale)
+            h=a.histogram(3)
+            assert_equal(4,h[0])
+            assert_equal(3,h[1])
+            assert_equal(2,h[2])
+            h=a.histogram([10,20,30,40])
+            assert_equal(4,h[0])
+            assert_equal(3,h[1])
+            assert_equal(2,h[2])
+            
+		end
+	end
+	def test_vector_matrix        
+		v1=%w{a a a b b b c c}.to_vector
+		v2=%w{1 3 4 5 6 4 3 2}.to_vector
+		v3=%w{1 0 0 0 1 1 1 0}.to_vector
+		ex=Matrix.rows([["a", "1", "1"], ["a", "3", "0"], ["a", "4", "0"], ["b", "5", "0"], ["b", "6", "1"], ["b", "4", "1"], ["c", "3", "1"], ["c", "2", "0"]])
+		assert_equal(ex,Statsample.vector_cols_matrix(v1,v2,v3))
+	end
+    def test_marshalling
+        v1=(0..100).to_a.collect{|n| rand(100)}.to_vector(:scale)
+        v2=Marshal.load(Marshal.dump(v1))
+        assert_equal(v1,v2)
+    end
+    def test_dup
+        v1=%w{a a a b b b c c}.to_vector
+        v2=v1.dup
+        assert_equal(v1.data,v2.data)
+        assert_not_same(v1.data,v2.data)
+        assert_equal(v1.type,v2.type)
+        
+        v1.type=:ordinal
+        assert_not_equal(v1.type,v2.type)
+        assert_equal(v1.missing_values,v2.missing_values)
+        assert_not_same(v1.missing_values,v2.missing_values)
+        assert_equal(v1.labels,v2.labels)
+        assert_not_same(v1.labels,v2.labels)
+        
+        v3=v1.dup_empty
+        assert_equal([],v3.data)
+        assert_not_equal(v1.data,v3.data)
+        assert_not_same(v1.data,v3.data)
+        assert_equal(v1.type,v3.type)
+        v1.type=:ordinal
+        v3.type=:nominal
+        assert_not_equal(v1.type,v3.type)
+        assert_equal(v1.missing_values,v3.missing_values)
+        assert_not_same(v1.missing_values,v3.missing_values)
+        assert_equal(v1.labels,v3.labels)
+        assert_not_same(v1.labels,v3.labels)
+    end
+     
+end

data/test/test_xls.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+require 'tmpdir'
+begin
+	require 'spreadsheet'
+rescue LoadError
+	puts "You should install spreadsheet (gem install spreadsheet)"
+end
+class StatsampleExcelTestCase < Test::Unit::TestCase
+	def initialize(*args)
+        @ds=Statsample::Excel.read(File.dirname(__FILE__)+"/test_xls.xls")
+		super
+	end
+    
+    def test_read
+        assert_equal(6,@ds.cases)
+        assert_equal(%w{id name age city a1},@ds.fields)
+    end
+    def test_nil
+        assert_equal(nil,@ds['age'][5])
+    end
+    def test_write
+        filename=Dir::tmpdir+"/test_write.xls"
+        Statsample::Excel.write(@ds,filename)
+        ds2=Statsample::Excel.read(filename)
+        i=0
+        ds2.each_array{|row|
+            assert_equal(@ds.case_as_array(i),row)
+               i+=1
+        }
+    end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: statsample
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Claudio Bustos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-03 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: spreadsheet
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.6.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: svg-graph
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.2
+    version: 
+description: This package allows to process files and databases for statistical purposes, with focus on validation, recodification and estimation of parameters for several types of samples (simple random, stratified and multistage sampling).
+email: 
+- clbustos@gmail.com
+executables: 
+- statsample
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/statsample
+- demo/benchmark.rb
+- demo/chi-square.rb
+- demo/dice.rb
+- demo/distribution_t.rb
+- demo/graph.rb
+- demo/item_analysis.rb
+- demo/mean.rb
+- demo/proportion.rb
+- demo/sample_test.csv
+- demo/strata_proportion.rb
+- demo/stratum.rb
+- lib/statsample.rb
+- lib/statsample/anova.rb
+- lib/statsample/bivariate.rb
+- lib/statsample/chidistribution.rb
+- lib/statsample/codification.rb
+- lib/statsample/converters.rb
+- lib/statsample/crosstab.rb
+- lib/statsample/dataset.rb
+- lib/statsample/dominanceanalysis.rb
+- lib/statsample/dominanceanalysis/bootstrap.rb
+- lib/statsample/graph/gdchart.rb
+- lib/statsample/graph/svggraph.rb
+- lib/statsample/graph/svgboxplot.rb
+- lib/statsample/graph/svghistogram.rb
+- lib/statsample/graph/svgscatterplot.rb
+- lib/statsample/htmlreport.rb
+- lib/statsample/multiset.rb
+- lib/statsample/regression.rb
+- lib/statsample/reliability.rb
+- lib/statsample/resample.rb
+- lib/statsample/srs.rb
+- lib/statsample/test.rb
+- lib/statsample/vector.rb
+- lib/spss.rb
+- test/_test_chart.rb
+- test/test_anova.rb
+- test/test_codification.rb
+- test/test_crosstab.rb
+- test/test_csv.csv
+- test/test_csv.rb
+- test/test_dataset.rb
+- test/test_ggobi.rb
+- test/test_multiset.rb
+- test/test_regression.rb
+- test/test_reliability.rb
+- test/test_resample.rb
+- test/test_statistics.rb
+- test/test_stratified.rb
+- test/test_svg_graph.rb
+- test/test_vector.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-statsample/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-statsample
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: This package allows to process files and databases for statistical purposes, with focus on validation, recodification and estimation of parameters for several types of samples (simple random, stratified and multistage sampling).
+test_files: 
+- test/test_anova.rb
+- test/test_codification.rb
+- test/test_crosstab.rb
+- test/test_svg_graph.rb
+- test/test_csv.rb
+- test/test_resample.rb
+- test/test_stratified.rb
+- test/test_vector.rb
+- test/test_srs.rb
+- test/test_ggobi.rb
+- test/test_xls.rb
+- test/test_statistics.rb
+- test/test_reliability.rb
+- test/test_dataset.rb
+- test/test_regression.rb
+- test/test_multiset.rb