statsample 0.3.0

data/test/test_ggobi.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'statsample/multiset'
+require 'test/unit'
+
+class StatsampleGGobiTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+		v1=([10.2,20.3,10,20,30,40,30,20,30,40]*10).to_vector(:scale)
+		@v2=(%w{a b c a a a b b c d}*10).to_vector(:nominal)
+		@v2.labels={"a"=>"letter a","d"=>"letter d"}
+		v3=([1,2,3,4,5,4,3,2,1,2]*10).to_vector(:ordinal)
+		@ds={'v1'=>v1,'v2'=>@v2,'v3'=>v3}.to_dataset
+	end
+	def test_values_definition
+		a=[1.0,2,"a"]
+		assert_equal("<real>1.0</real> <int>2</int> <string>a</string>",Statsample::GGobi.values_definition(a))
+	end
+	def test_variable_definition
+		carrier=OpenStruct.new
+		carrier.categorials=[]
+		carrier.conversions={}
+		real_var_definition=Statsample::GGobi.variable_definition(carrier,@v2,'variable 2',"v2")
+		expected=<<EOS
+<categoricalvariable name="variable 2" nickname="v2">
+<levels count="4">
+<level value="1">letter a</level>
+<level value="2">b</level>
+<level value="3">c</level>
+<level value="4">letter d</level></levels>
+</categoricalvariable>
+EOS
+assert_equal(expected.gsub(/\s/," "),real_var_definition.gsub(/\s/," "))
+assert_equal({'variable 2'=>{'a'=>1,'b'=>2,'c'=>3,'d'=>4}},carrier.conversions)
+	assert_equal(['variable 2'],carrier.categorials)
+	end
+	def test_out
+		filename="/tmp/test_statsample_ggobi.xml"
+		go=Statsample::GGobi.out(@ds)
+		
+	end
+end

data/test/test_multiset.rb

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__)+'/../lib/statsample.rb'
+require 'statsample/multiset'
+require 'test/unit'
+
+class StatsampleMultisetTestCase < Test::Unit::TestCase
+	def initialize(*args)
+		super
+	end
+    def test_creation
+        v1a=[1,2,3,4,5].to_vector
+        v2b=[11,21,31,41,51].to_vector
+        v3c=[21,23,34,45,56].to_vector
+        ds1={'v1'=>v1a,'v2'=>v2b,'v3'=>v3c}.to_dataset
+        v1b=[15,25,35,45,55].to_vector
+        v2b=[11,21,31,41,51].to_vector
+        v3b=[21,23,34,45,56].to_vector
+        ds2={'v1'=>v1b,'v2'=>v2b,'v3'=>v3b}.to_dataset
+        ms=Statsample::Multiset.new(['v1','v2','v3'])
+        ms.add_dataset('ds1',ds1)
+        ms.add_dataset('ds2',ds2)
+        assert_equal(ds1,ms['ds1'])
+        assert_equal(ds2,ms['ds2'])
+        assert_equal(v1a,ms['ds1']['v1'])
+        assert_not_equal(v1b,ms['ds1']['v1'])
+        ds3={'v1'=>v1b,'v2'=>v2b}.to_dataset
+        assert_raise ArgumentError do
+			ms.add_dataset(ds3)
+		end
+    end
+    def test_creation_empty
+        ms=Statsample::Multiset.new_empty_vectors(%w{id age name},%w{male female})
+        ds_male={'id'=>[].to_vector,'age'=>[].to_vector, 'name'=>[].to_vector}.to_dataset(%w{id age name})
+        ds_female={'id'=>[].to_vector,'age'=>[].to_vector, 'name'=>[].to_vector}.to_dataset(%w{id age name})
+        ms2=Statsample::Multiset.new(%w{id age name})
+        ms2.add_dataset('male',ds_male)
+        ms2.add_dataset('female',ds_female)
+        assert_equal(ms2.fields,ms.fields)
+        assert_equal(ms2['male'],ms['male'])
+        assert_equal(ms2['female'],ms['female'])        
+    end
+    def test_to_multiset_by_split_one
+        sex=%w{m m m m m f f f f m}.to_vector(:nominal)
+        city=%w{London Paris NY London Paris NY London Paris NY Tome}.to_vector(:nominal)
+        age=[10,10,20,30,34,34,33,35,36,40].to_vector(:scale)
+        ds={'sex'=>sex,'city'=>city,'age'=>age}.to_dataset
+        ms=ds.to_multiset_by_split('sex')
+        assert_equal(2,ms.n_datasets)
+        assert_equal(%w{f m},ms.datasets.keys.sort)
+        assert_equal(6,ms['m'].cases)
+        assert_equal(4,ms['f'].cases)
+        assert_equal(%w{London Paris NY London Paris Tome},ms['m']['city'].to_a)
+        assert_equal([34,33,35,36],ms['f']['age'].to_a)        
+    end
+    def test_to_multiset_by_split_multiple
+        sex=%w{m m m m m m m m m m f f f f f f f f f f}.to_vector(:nominal)
+        city=%w{London London London Paris Paris London London London Paris Paris London London London Paris Paris London London London Paris Paris}.to_vector(:nominal)
+		hair=%w{blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black blonde blonde black black}.to_vector(:nominal)
+        age=[10,10,20,30,34,34,33,35,36,40, 10,10,20,30,34,34,33,35,36,40].to_vector(:scale)
+        ds={'sex'=>sex,'city'=>city,'hair'=>hair,'age'=>age}.to_dataset(%w{sex city hair age})
+        ms=ds.to_multiset_by_split('sex','city','hair')
+        assert_equal(8,ms.n_datasets)
+		assert_equal(3,ms[%w{m London blonde}].cases)
+		assert_equal(3,ms[%w{m London blonde}].cases)
+		assert_equal(1,ms[%w{m Paris black}].cases)		
+    end
+	
+    def test_stratum_proportion
+        ds1={'q1'=>[1,1,1,1,1,0,0,0,0,0,0,0].to_vector}.to_dataset
+        ds2={'q1'=>[1,1,1,1,1,1,1,0,0].to_vector}.to_dataset
+        assert_equal(5.0/12, ds1['q1'].proportion )
+        assert_equal(7.0/9, ds2['q1'].proportion )
+        ms=Statsample::Multiset.new(['q1'])
+        ms.add_dataset('d1',ds1)
+        ms.add_dataset('d2',ds2)
+        ss=Statsample::StratifiedSample.new(ms,{'d1'=>50,'d2'=>100})
+        assert_in_delta(0.655, ss.proportion('q1'),0.01)
+        assert_in_delta(0.345, ss.proportion('q1',0),0.01)        
+        
+    end
+    def test_stratum_scale
+        boys={'test'=>[50, 55, 60, 62, 62, 65, 67, 67, 70, 70, 73, 73, 75, 78, 78, 80, 85, 90].to_vector(:scale)}.to_dataset
+        girls={'test'=>[70, 70, 72, 72, 75, 75, 78, 78, 80, 80, 82, 82, 85, 85, 88, 88, 90, 90].to_vector(:scale)}.to_dataset
+        ms=Statsample::Multiset.new(['test'])
+        ms.add_dataset('boys',boys)
+        ms.add_dataset('girls',girls)
+        ss=Statsample::StratifiedSample.new(ms,{'boys'=>10000,'girls'=>10000})
+        assert_equal(2,ss.strata_number)
+        assert_equal(20000,ss.population_size)
+        assert_equal(10000,ss.stratum_size('boys'))
+        assert_equal(10000,ss.stratum_size('girls'))
+        assert_equal(36,ss.sample_size)
+        assert_equal(75,ss.mean('test'))
+        assert_in_delta(1.45,ss.standard_error_wor('test'),0.01)
+        assert_in_delta(ss.standard_error_wor('test'), ss.standard_error_wor_2('test'),0.00001)
+        
+        
+    end
+end

data/test/test_regression.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+class StatsampleRegressionTestCase < Test::Unit::TestCase
+	def initialize(*args)
+		@x=[13,20,10,33,15].to_vector(:scale)
+		@y=[23,18,35,10,27	].to_vector(:scale)
+		@reg=Statsample::Regression::SimpleRegression.new_from_vectors(@x,@y)
+		super
+	end
+	def test_parameters
+		assert_in_delta(40.009, @reg.a,0.001)
+		assert_in_delta(-0.957, @reg.b,0.001)
+		assert_in_delta(4.248,@reg.standard_error,0.002)
+	end
+    def test_multiple_regression_pairwise_2
+        @a=[1,3,2,4,3,5,4,6,5,7,3,nil,3,nil,3].to_vector(:scale)
+        @b=[3,3,4,4,5,5,6,6,4,4,2,2,nil,6,2].to_vector(:scale)
+        @c=[11,22,30,40,50,65,78,79,99,100,nil,3,7,nil,7].to_vector(:scale)
+        @y=[3,4,5,6,7,8,9,10,20,30,30,40,nil,50,nil].to_vector(:scale)
+        ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+        lr=Statsample::Regression::MultipleRegressionPairwise.new(ds,'y')
+        assert_in_delta(2407.436,lr.sst,0.001)
+        assert_in_delta(0.752,lr.r,0.001)
+        assert_in_delta(0.565,lr.r2,0.001)
+        assert_in_delta(1361.130,lr.ssr,0.001)
+        assert_in_delta(1046.306,lr.sse,0.001)
+        assert_in_delta(3.035,lr.f,0.001)
+        
+    end
+    def test_multiple_regression_alglib
+	    if HAS_ALGIB
+        @a=[1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
+        @b=[3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
+        @c=[11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
+        @y=[3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
+        ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+        lr=Statsample::Regression::MultipleRegressionAlglib.new(ds,'y')
+        model_test(lr)
+        predicted=[1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+        c_predicted=lr.predicted
+        predicted.each_index{|i|
+            assert_in_delta(predicted[i],c_predicted[i],0.001)
+        }
+        residuals=[1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+        c_residuals=lr.residuals
+        residuals.each_index{|i|
+            assert_in_delta(residuals[i],c_residuals[i],0.001)
+        }
+	else
+		puts "Regression::MultipleRegressionAlglib not tested (no Alglib)"
+	end
+    end
+    def model_test(lr)
+        assert_in_delta(0.695,lr.coeffs['a'],0.001)
+        assert_in_delta(11.027,lr.constant,0.001)
+        assert_in_delta(1.785,lr.process([1,3,11]),0.001)
+        
+        
+        s_coeffs={'a'=>0.151,'b'=>-0.547,'c'=>0.997}
+        cs_coeefs=lr.standarized_coeffs
+        s_coeffs.each_key{|k|
+            assert_in_delta(s_coeffs[k],cs_coeefs[k],0.001)
+        }
+        assert_in_delta(639.6,lr.sst,0.001)
+        assert_in_delta(583.76,lr.ssr,0.001)
+        assert_in_delta(55.840,lr.sse,0.001)
+        assert_in_delta(0.955,lr.r,0.001)
+        assert_in_delta(0.913,lr.r2,0.001)
+        assert_in_delta(20.908, lr.f,0.001)
+	if HAS_GSL
+        assert_in_delta(0.001, lr.significance, 0.001)
+	else
+		puts "#{lr.class}#significance not tested (not GSL)"
+	end
+        assert_in_delta(0.226,lr.tolerance("a"),0.001)
+        coeffs_se={"a"=>1.171,"b"=>1.129,"c"=>0.072}
+        ccoeffs_se=lr.coeffs_se
+        coeffs_se.each_key{|k|
+            assert_in_delta(coeffs_se[k],ccoeffs_se[k],0.001)
+        }
+        coeffs_t={"a"=>0.594,"b"=>-3.796,"c"=>3.703}
+        ccoeffs_t=lr.coeffs_t
+        coeffs_t.each_key{|k|
+            assert_in_delta(coeffs_t[k], ccoeffs_t[k],0.001)
+        }
+        assert_in_delta(4.559, lr.constant_se,0.001)
+        assert_in_delta(2.419, lr.constant_t,0.001)
+    end
+    def test_regression_pairwise
+        @a=[nil,1,3,2,4,3,5,4,6,5,7].to_vector(:scale)
+        @b=[nil,3,3,4,4,5,5,6,6,4,4].to_vector(:scale)
+        @c=[nil,11,22,30,40,50,65,78,79,99,100].to_vector(:scale)
+        @y=[nil,3,4,5,6,7,8,9,10,20,30].to_vector(:scale)
+        ds={'a'=>@a,'b'=>@b,'c'=>@c,'y'=>@y}.to_dataset
+        lr=Statsample::Regression::MultipleRegressionPairwise.new(ds,'y')
+        model_test(lr)
+        predicted=[nil,1.7857, 6.0989, 3.2433, 7.2908, 4.9667, 10.3428, 8.8158, 10.4717, 23.6639, 25.3198]
+        c_predicted = lr.predicted
+        predicted.each_index{|i|
+            assert_in_delta(predicted[i],c_predicted[i],0.001)
+        }
+        residuals=[nil,1.2142, -2.0989, 1.7566, -1.29085, 2.033, -2.3428, 0.18414, -0.47177, -3.66395, 4.6801]
+        c_residuals=lr.residuals
+        residuals.each_index{|i|
+            assert_in_delta(residuals[i],c_residuals[i],0.001)
+        }
+    end
+end

data/test/test_reliability.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleReliabilityTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+        @x1=[1,1,1,1,2,2,2,2,3,3,3,30].to_vector(:scale)
+        @x2=[1,1,1,2,2,3,3,3,3,4,4,50].to_vector(:scale)
+        @x3=[2,2,1,1,1,2,2,2,3,4,5,40].to_vector(:scale)
+        @x4=[1,2,3,4,4,4,4,3,4,4,5,30].to_vector(:scale)
+        @ds={'x1'=>@x1,'x2'=>@x2,'x3'=>@x3,'x4'=>@x4}.to_dataset
+	end
+   
+    def test_general
+        ia=Statsample::Reliability::ItemAnalysis.new(@ds)
+        assert_in_delta(0.980,ia.alpha,0.001)
+        assert_in_delta(0.999,ia.alpha_standarized,0.001)
+        assert_in_delta(0.999,ia.item_total_correlation()['x1'],0.001)
+        assert_in_delta(1050.455,ia.stats_if_deleted()['x1'][:variance_sample],0.001)
+    end	
+    def test_icc
+        #p @x1.factors
+        icc=Statsample::Reliability::ItemCharacteristicCurve.new(@ds)
+        # Need to create the test!!!!
+        #p icc.curve_field('x1',1).sort
+        #p icc.curve_field('x1',2).sort
+        #p icc.curve_field('x1',3).sort
+        #p icc.curve_field('x1',30).sort
+        
+    end
+end

data/test/test_resample.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleResampleTestCase < Test::Unit::TestCase
+	def initialize(*args)
+		super
+	end
+    def test_basic
+        r=Statsample::Resample.generate(20,1,10)
+        assert_equal(20,r.size)
+        assert(r.min>=1)
+        assert(r.max<=10)
+    end
+    def test_repeat_and_save
+        r=Statsample::Resample.repeat_and_save(400) {
+            Statsample::Resample.generate(20,1,10).count(1)
+        }
+        assert_equal(400,r.size)
+        v=Statsample::Vector.new(r,:scale)
+        a=v.count {|x|  x > 3}
+        assert(a>=30 && a<=70)
+    end
+end

data/test/test_srs.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleSrsTestCase < Test::Unit::TestCase
+    def test_std_error
+	if HAS_GSL
+        assert_equal(384,Statsample::SRS.estimation_n0(0.05,0.5,0.95).to_i)
+        assert_equal(108,Statsample::SRS.estimation_n(0.05,0.5,150,0.95).to_i)
+	else
+		puts "Statsample::SRS.estimation_n0 not tested (needs ruby-gsl)"
+	end
+        assert_in_delta(0.0289,Statsample::SRS.proportion_sd_kp_wor(0.5,100,150),0.001)
+    end
+end

data/test/test_statistics.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleStatisicsTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+	end
+    def test_chi_square
+        assert_raise TypeError do
+            Statsample::Test.chi_square(1,1)
+        end
+        real=Matrix[[95,95],[45,155]]
+        expected=Matrix[[68,122],[72,128]]
+        assert_nothing_raised do
+            chi=Statsample::Test.chi_square(real,expected)
+        end
+        chi=Statsample::Test.chi_square(real,expected)
+        assert_in_delta(32.53,chi,0.1)
+    end
+	def test_sum_of_codeviated
+		v1=[1,2,3,4,5,6].to_vector(:scale)
+		v2=[6,2,4,10,12,8].to_vector(:scale)
+		assert_equal(23.0, Statsample::Bivariate.sum_of_codeviated(v1,v2))
+	end
+    def test_pearson
+        v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
+        v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
+        assert_in_delta(0.525,Statsample::Bivariate.pearson(v1,v2), 0.001)
+        v3=[6,2,  1000,1000,5,4,7,8,4,3,2,nil].to_vector(:scale)
+        v4=[2,nil,nil,nil,  3,7,8,6,4,3,2,500].to_vector(:scale)
+        assert_in_delta(0.525,Statsample::Bivariate.pearson(v3,v4),0.001)
+    end
+    def test_matrix_correlation
+        v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
+        v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
+        v3=[6,2,  1000,1000,5,4,7,8].to_vector(:scale)
+        v4=[2,nil,nil,nil,  3,7,8,6].to_vector(:scale)
+        ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4}.to_dataset
+        c=Proc.new {|n1,n2|Statsample::Bivariate.pearson(n1,n2)} 
+        expected=Matrix[ [c.call(v1,v1),c.call(v1,v2),c.call(v1,v3),c.call(v1,v4)], [c.call(v2,v1),c.call(v2,v2),c.call(v2,v3),c.call(v2,v4)], [c.call(v3,v1),c.call(v3,v2),c.call(v3,v3),c.call(v3,v4)],
+        [c.call(v4,v1),c.call(v4,v2),c.call(v4,v3),c.call(v4,v4)]
+        ]
+	obt=Statsample::Bivariate.correlation_matrix(ds)
+	for i in 0...expected.row_size
+	for j in 0...expected.column_size
+		#puts expected[i,j].inspect
+		#puts obt[i,j].inspect
+		assert_in_delta(expected[i,j], obt[i,j],0.0001,"#{expected[i,j].class}!=#{obt[i,j].class}  ")
+	end
+	end
+#assert_equal(expected,obt)
+    end
+    def test_prop_pearson
+	if HAS_GSL    
+        assert_in_delta(0.42,Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.084,94),94),0.01)        
+        assert_in_delta(0.65,Statsample::Bivariate.prop_pearson(Statsample::Bivariate.t_r(0.046,95),95),0.01)
+	else
+		puts "Bivariate.prop_pearson not tested (no ruby-gsl)"
+	end
+    end
+	def test_covariance
+		if HAS_GSL
+			v1=[6,5,4,7,8,4,3,2].to_vector(:scale)
+			v2=[2,3,7,8,6,4,3,2].to_vector(:scale)
+			assert_in_delta(Statsample::Bivariate.covariance(v1,v2), Statsample::Bivariate.covariance_slow(v1,v2), 0.001)
+			
+		end
+	end
+	def test_spearman
+		v1=[86,97,99,100,101,103,106,110,112,113].to_vector(:scale)
+		v2=[0,20,28,27,50,29,7,17,6,12].to_vector(:scale)
+        assert_in_delta(-0.175758,Statsample::Bivariate.spearman(v1,v2),0.0001)
+	end
+	def test_point_biserial
+		c=[1,3,5,6,7,100,200,300,400,300].to_vector(:scale)
+		d=[1,1,1,1,1,0,0,0,0,0].to_vector(:scale)
+		assert_raise TypeError do
+			Statsample::Bivariate.point_biserial(c,d)
+		end
+		assert_in_delta(Statsample::Bivariate.point_biserial(d,c), Statsample::Bivariate.pearson(d,c), 0.0001)
+	end
+	def test_tau
+		v1=[1,2,3,4,5,6,7,8,9,10,11].to_vector(:ordinal)
+		v2=[1,3,4,5,7,8,2,9,10,6,11].to_vector(:ordinal)
+		assert_in_delta(0.6727,Statsample::Bivariate.tau_a(v1,v2),0.001)
+		assert_in_delta(0.6727,Statsample::Bivariate.tau_b((Statsample::Crosstab.new(v1,v2).to_matrix)),0.001)
+		v1=[12,14,14,17,19,19,19,19,19,20,21,21,21,21,21,22,23,24,24,24,26,26,27].to_vector(:ordinal)
+		v2=[11,4,4,2,0,0,0,0,0,0,4,0,4,0,0,0,0,4,0,0,0,0,0].to_vector(:ordinal)
+		assert_in_delta(-0.376201540231705, Statsample::Bivariate.tau_b(Statsample::Crosstab.new(v1,v2).to_matrix),0.001)
+	end
+	def test_gamma
+		m=Matrix[[10,5,2],[10,15,20]]
+		assert_in_delta(0.636,Statsample::Bivariate.gamma(m),0.001)
+		m2=Matrix[[15,12,6,5],[12,8,10,8],[4,6,9,10]]
+		assert_in_delta(0.349,Statsample::Bivariate.gamma(m2),0.001)
+		
+
+	end
+    def test_estimation_mean              
+        v=([42]*23+[41]*4+[36]*1+[32]*1+[29]*1+[27]*2+[23]*1+[19]*1+[16]*2+[15]*2+[14,11,10,9,7]+ [6]*3+[5]*2+[4,3]).to_vector(:scale)
+        assert_equal(50,v.size)
+        assert_equal(1471,v.sum())
+	if HAS_GSL
+        limits=Statsample::SRS.mean_confidence_interval_z(v.mean(), v.sds(), v.size,676,0.80)
+       else
+	       puts "SRS.mean_confidence_interval_z not tested (no ruby-gsl)"
+	       end
+    end
+    def test_estimation_proportion
+        # total
+        pop=3042
+        sam=200
+        prop=0.19
+        assert_in_delta(81.8, Statsample::SRS.proportion_total_sd_ep_wor(prop, sam, pop), 0.1)
+        
+        # confidence limits
+        pop=500
+        sam=100
+        prop=0.37
+        a=0.95
+	if HAS_GSL
+        l= Statsample::SRS.proportion_confidence_interval_z(prop, sam, pop, a)
+        assert_in_delta(0.28,l[0],0.01)
+        assert_in_delta(0.46,l[1],0.01)
+	else
+	       puts "SRS.proportion_confidence_interval_z not tested (no ruby-gsl)"
+		
+		end
+    end
+    def test_simple_linear_regression
+		a=[1,2,3,4,5,6].to_vector(:scale)
+		b=[6,2,4,10,12,8].to_vector(:scale)
+		reg = Statsample::Regression::SimpleRegression.new_from_vectors(a,b)
+        assert_in_delta((reg.ssr+reg.sse).to_f,reg.sst,0.001)
+        assert_in_delta(Statsample::Bivariate.pearson(a,b),reg.r,0.001)
+		assert_in_delta(2.4,reg.a,0.01)
+		assert_in_delta(1.314,reg.b,0.001)
+		assert_in_delta(0.657,reg.r,0.001)
+		assert_in_delta(0.432,reg.r2,0.001)
+        
+	end
+    def a_test_multiple_regression
+        x1=[1,2,3,4,5,6].to_vector(:scale)
+        x2=[3,5,8,9,10,20].to_vector(:scale)
+        x3=[100,90,50,30,50,10].to_vector(:scale)
+		y=[6,2,4,10,12,8].to_vector(:scale)
+        reg=Statsample::Regression::MultipleRegression.new_from_vectors([x1,x2,x3],y)
+        # p reg
+    end
+    
+end