statsample 0.3.0

data/test/_test_chart.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'tempfile'
+require 'test/unit'
+require 'statsample/chart/gdchart'
+# Not included on default test, because GDChart send a lot of warnings!
+class StatsampleChartTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		@image_path=File.dirname(__FILE__)+"/images"
+		super
+	end
+
+	def test_base_chart
+		file=@image_path+"/gdchart_base_bar_1.jpg"
+		width=500
+		height=300
+		chart_type=GDChart::BAR
+		labels=["a","b","c","d","e"]
+		options={'set_color'=>[0xFF3399]}
+		n_data=1
+		data=[10,40,30,20,40]
+		
+		Statsample::Util.chart_gdchart(file,width,height,chart_type, labels, options,n_data,data)
+		assert(File.exists?(file))
+		%w{STACK_DEPTH STACK_SUM STACK_BESIDE STACK_LAYER}.each{|stack|
+			file=@image_path+"/gdchart_base_bar_2_#{stack}.jpg"
+			n_data=2
+			options={'set_color'=>[0xFF3399,0x33FF99,0xFF99FF,0xFF3399], 'stack_type'=>GDChart.const_get(stack.intern),'title'=>"Bar #{stack}"}
+	
+			chart_type=GDChart::BAR
+			
+			data=[10,15,10,20,30,30,20,5,15,20]
+			Statsample::Util.chart_gdchart(file,width,height,chart_type, labels, options,n_data,data)
+			assert(File.exists?(file))
+		}
+	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+"/gdchart_bar.jpg"
+		vector.gdchart_frequencies(file,800,600,GDChart::BAR,'title'=>'Bar')
+		assert(File.exists?(file))
+		file=@image_path+"/gdchart_bar3d.jpg"
+		vector.gdchart_frequencies(file,300,100,GDChart::BAR3D,'title'=>'Bar3D')
+		assert(File.exists?(file))
+		file=@image_path+"/gdchart_floatingbar.jpg"
+		vector.gdchart_frequencies(file,200,200,GDChart::LINE,'title'=>'FloatingBar')
+		assert(File.exists?(file))
+		vector.type=:scale
+		file=@image_path+"/gdchart_histogram.jpg"		
+		vector.gdchart_histogram(5,file,300,400,GDChart::BAR,'title'=>'Histogram')
+		assert(File.exists?(file))
+	end
+end

data/test/test_anova.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__)+'/../lib/statsample.rb'
+require 'test/unit'
+
+class StatsampleAnovaTestCase < Test::Unit::TestCase
+	def initialize(*args)
+        @v1=[3,3,2,3,6].to_vector(:scale)
+        @v2=[7,6,5,6,7].to_vector(:scale)
+        @v3=[9,8,9,7,8].to_vector(:scale)
+        @anova=Statsample::Anova::OneWay.new([@v1,@v2,@v3])
+		super
+	end
+    def test_basic
+	assert_in_delta(72.933, @anova.sst,0.001)
+        assert_in_delta(14.8,@anova.sswg,0.001)
+        assert_in_delta(58.133,@anova.ssbg,0.001)
+	assert_in_delta(@anova.sst,@anova.sswg+@anova.ssbg,0.00001)
+        assert_equal(14,@anova.df_total)
+        assert_equal(12,@anova.df_wg)
+        assert_equal(2,@anova.df_bg)
+        assert_in_delta(23.568,@anova.f,0.001)
+        anova2=Statsample::Anova::OneWay.new([@v1,@v1,@v1,@v1,@v2])
+        assert_in_delta(3.960, anova2.f,0.001)
+
+	if HAS_GSL
+		assert(@anova.significance<0.01)
+		assert_in_delta(0.016, anova2.significance,0.001)
+	else
+		puts "Skipped OneWay#significance (no GSL)"
+	end
+    end
+end

data/test/test_codification.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'tempfile'
+require 'test/unit'
+
+class StatsampleCodificationTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+        v1=%w{run walk,run walking running sleep sleeping,dreaming sleep,dream}.to_vector
+        @dict={'run'=>'r','walk'=>'w','walking'=>'w','running'=>'r','sleep'=>'s', 'sleeping'=>'s','dream'=>'d','dreaming'=>'d'}
+        @ds={"v1"=>v1}.to_dataset
+		super
+	end
+    def test_create_yaml
+        assert_raise  ArgumentError do
+            Statsample::Codification.create_yaml(@ds,[])
+        end
+        expected_keys_v1=%w{run walk walking running sleep sleeping dream dreaming}.sort
+        yaml_hash=Statsample::Codification.create_yaml(@ds,['v1'])
+        h=YAML::load(yaml_hash)
+        assert_equal(['v1'],h.keys)
+        assert_equal(expected_keys_v1,h['v1'].keys.sort)
+        tf = Tempfile.new("test_codification")
+        yaml_hash=Statsample::Codification.create_yaml(@ds,['v1'],Statsample::SPLIT_TOKEN,tf)
+        tf.close
+        tf.open
+        h=YAML::load(tf)
+        assert_equal(['v1'],h.keys)
+        assert_equal(expected_keys_v1,h['v1'].keys.sort)
+        tf.close(true)
+    end
+    def test_recodification
+        expected=[['r'],['w','r'],['w'],['r'],['s'],['s','d'], ['s','d']]
+        assert_equal(expected,Statsample::Codification.recode_vector(@ds['v1'],@dict))
+        v2=['run','walk,dreaming',nil,'walk,dream,dreaming,walking'].to_vector
+        expected=[['r'],['w','d'],nil,['w','d']]
+        assert_equal(expected,Statsample::Codification.recode_vector(v2,@dict))
+    end
+    def test_recode_dataset_simple
+        yaml=YAML::dump({'v1'=>@dict})
+        Statsample::Codification.recode_dataset_simple!(@ds,yaml)
+        expected_vector=['r','w,r','w','r','s','s,d', 's,d'].to_vector
+        assert_not_equal(expected_vector,@ds['v1'])
+        assert_equal(expected_vector,@ds['v1_recoded'])
+    end
+    def test_recode_dataset_split
+        yaml=YAML::dump({'v1'=>@dict})
+        Statsample::Codification.recode_dataset_split!(@ds,yaml)
+        e={}
+        e['r']=[1,1,0,1,0,0,0].to_vector
+        e['w']=[0,1,1,0,0,0,0].to_vector
+        e['s']=[0,0,0,0,1,1,1].to_vector
+        e['d']=[0,0,0,0,0,1,1].to_vector
+        e.each{|k,expected|
+            assert_equal(expected,@ds['v1_'+k],"Error on key #{k}")
+
+        }
+    end
+
+end

data/test/test_crosstab.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'statsample/crosstab'
+require 'test/unit'
+
+class StatsampleCrosstabTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		@v1=%w{black blonde black black red black brown black blonde black red black blonde}.to_vector
+		@v2=%w{woman man man woman man man man woman man woman woman man man}.to_vector
+		@ct=Statsample::Crosstab.new(@v1,@v2)
+		super
+	end
+	def test_crosstab_errors
+		e1=%w{black blonde black black red black brown black blonde black}
+		assert_raise ArgumentError do
+			Statsample::Crosstab.new(e1,@v2)
+		end
+		e2=%w{black blonde black black red black brown black blonde black black}.to_vector
+		
+		assert_raise ArgumentError do
+			Statsample::Crosstab.new(e2,@v2)
+		end
+		assert_nothing_raised do
+			Statsample::Crosstab.new(@v1,@v2)
+		end
+	end
+	def test_crosstab_basic
+		assert_equal(%w{black blonde brown red}, @ct.rows_names)
+		assert_equal(%w{man woman}, @ct.cols_names)
+		assert_equal({'black'=>7,'blonde'=>3,'red'=>2,'brown'=>1}, @ct.rows_total)
+		assert_equal({'man'=>8,'woman'=>5}, @ct.cols_total)
+	end
+	def test_crosstab_frequencies
+		fq=@ct.frequencies
+        assert_equal(8,fq.size)
+        sum=fq.inject(0) {|s,x| s+x[1]}
+        assert_equal(13,sum)
+        fr=@ct.frequencies_by_row
+        assert_equal(4,fr.size)
+        assert_equal(%w{black blonde brown red},fr.keys.sort)
+        fc=@ct.frequencies_by_col
+        assert_equal(2,fc.size)
+        assert_equal(%w{man woman},fc.keys.sort)
+        assert_equal(Matrix.rows([[3,4],[3,0],[1,0],[1,1]]),@ct.to_matrix)
+	end
+    def test_expected
+        v1=%w{1 1 1 1 1 0 0 0 0 0}.to_vector
+        v2=%w{0 0 0 0 0 1 1 1 1 1}.to_vector
+        ct=Statsample::Crosstab.new(v1,v2)
+        assert_equal(Matrix[[2.5,2.5],[2.5,2.5]],ct.matrix_expected)
+    end
+    def test_to_s
+        assert_match(/man\s+|\s+woman/,@ct.to_s)
+    end
+end

data/test/test_csv.csv

@@ -0,0 +1,7 @@
+"id","name","age","city","a1"
+1,"Alex",20,"New York","a,b"
+2,"Claude",23,"London","b,c"
+3,"Peter",25,"London","a"
+4,"Franz",27,"Paris",
+5,"George",5,"Tome","a,b,c"
+6,"Fernand",,,

data/test/test_csv.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+	require 'tmpdir'
+require 'test/unit'
+
+class StatsampleCSVTestCase < Test::Unit::TestCase
+	def initialize(*args)
+        @ds=Statsample::CSV.read(File.dirname(__FILE__)+"/test_csv.csv")
+		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.csv"
+        Statsample::CSV.write(@ds,filename)
+        ds2=Statsample::CSV.read(filename)
+        i=0
+        ds2.each_array{|row|
+            assert_equal(@ds.case_as_array(i),row)
+               i+=1
+        }
+    end
+end

data/test/test_dataset.rb

@@ -0,0 +1,293 @@
+require File.dirname(__FILE__)+'/../lib/statsample'
+require 'test/unit'
+
+class StatsampleDatasetTestCase < Test::Unit::TestCase
+	def initialize(*args)
+        @ds=Statsample::Dataset.new({'id' => Statsample::Vector.new([1,2,3,4,5]), 'name'=>Statsample::Vector.new(%w{Alex Claude Peter Franz George}), 'age'=>Statsample::Vector.new([20,23,25,27,5]),
+        'city'=>Statsample::Vector.new(['New York','London','London','Paris','Tome']),
+        'a1'=>Statsample::Vector.new(['a,b','b,c','a',nil,'a,b,c'])}, ['id','name','age','city','a1'])
+		super
+	end
+    def test_basic
+        assert_equal(5,@ds.cases)
+        assert_equal(%w{id name age city a1}, @ds.fields)
+    end
+    def test_matrix
+        matrix=Matrix[[1,2],[3,4],[5,6]]
+        ds=Statsample::Dataset.new('v1'=>[1,3,5].to_vector,'v2'=>[2,4,6].to_vector)
+        assert_equal(matrix,ds.to_matrix)
+    end
+    
+    def test_fields
+        @ds.fields=%w{name a1 id age city}
+        assert_equal(%w{name a1 id age city}, @ds.fields)
+        @ds.fields=%w{id name age}
+        assert_equal(%w{id name age a1 city}, @ds.fields) 
+    end
+    def test_each_vector
+        a=[1,2,3].to_vector
+        b=[3,4,5].to_vector
+        fields=["a","b"]
+        ds=Statsample::Dataset.new({'a'=>a,'b'=>b},fields)
+        res=[]
+        ds.each_vector{|k,v|
+            res.push([k,v])
+        }
+        assert_equal([["a",a],["b",b]],res)
+        ds.fields=["b","a"]
+        res=[]
+        ds.each_vector{|k,v|
+            res.push([k,v])
+        }
+        assert_equal([["b",b],["a",a]],res)
+    end
+    def test_equality
+        v1=[1,2,3,4].to_vector
+        v2=[5,6,7,8].to_vector
+        ds1=Statsample::Dataset.new({'v1'=>v1,'v2'=>v2}, %w{v2 v1})
+        v3=[1,2,3,4].to_vector
+        v4=[5,6,7,8].to_vector
+        ds2=Statsample::Dataset.new({'v1'=>v3,'v2'=>v4}, %w{v2 v1})
+        assert_equal(ds1,ds2)
+        ds2.fields=%w{v1 v2}
+        assert_not_equal(ds1,ds2)
+    end
+    def test_add_vector
+        v=Statsample::Vector.new(%w{a b c d e})
+        @ds.add_vector('new',v)
+        assert_equal(%w{id name age city a1 new},@ds.fields)
+        x=Statsample::Vector.new(%w{a b c d e f g})
+        assert_raise ArgumentError do 
+            @ds.add_vector('new2',x)
+        end
+    end
+	def test_vector_by_calculation
+		a1=[1,2,3,4,5,6,7].to_vector(:scale)
+		a2=[10,20,30,40,50,60,70].to_vector(:scale)
+		a3=[100,200,300,400,500,600,700].to_vector(:scale)
+		ds={'a1'=>a1,'a2'=>a2,'a3'=>a3}.to_dataset
+		total=ds.vector_by_calculation() {|row|
+			row['a1']+row['a2']+row['a3']
+		}
+		expected=[111,222,333,444,555,666,777].to_vector(:scale)
+		assert_equal(expected,total)
+	end
+	def test_vector_sum
+		a1=[1  ,2 ,3 ,4  , 5,nil].to_vector(:scale)
+		a2=[10 ,10,20,20 ,20,30].to_vector(:scale)
+		b1=[nil,1 ,1 ,1  ,1 ,2].to_vector(:scale)
+		b2=[2  ,2 ,2 ,nil,2 ,3].to_vector(:scale)
+		ds={'a1'=>a1,'a2'=>a2,'b1'=>b1,'b2'=>b2}.to_dataset
+		total=ds.vector_sum
+		a=ds.vector_sum(['a1','a2'])
+		b=ds.vector_sum(['b1','b2'])
+		expected_a=[11,12,23,24,25,nil].to_vector(:scale)
+		expected_b=[nil,3,3,nil,3,5].to_vector(:scale)
+		expected_total=[nil,15,26,nil,28,nil].to_vector(:scale)
+		assert_equal(expected_a, a)
+		assert_equal(expected_b, b)
+		assert_equal(expected_total, total)
+	end
+    def test_vector_missing_values
+        a1=[1  ,nil ,3 ,4  , 5,nil].to_vector(:scale)
+		a2=[10 ,nil ,20,20 ,20,30].to_vector(:scale)
+		b1=[nil,nil ,1 ,1  ,1 ,2].to_vector(:scale)
+		b2=[2  ,2   ,2 ,nil,2 ,3].to_vector(:scale)
+        c= [nil,2   , 4,2   ,2 ,2].to_vector(:scale)
+		ds={'a1'=>a1,'a2'=>a2,'b1'=>b1,'b2'=>b2,'c'=>c}.to_dataset
+        mva=[2,3,0,1,0,1].to_vector(:scale)
+        assert_equal(mva,ds.vector_missing_values)
+    end
+    def test_vector_count_characters
+        a1=[1  ,"abcde"  ,3  ,4  , 5,nil].to_vector(:scale)
+		a2=[10 ,20.3     ,20 ,20 ,20,30].to_vector(:scale)
+		b1=[nil,"343434" ,1  ,1  ,1 ,2].to_vector(:scale)
+		b2=[2  ,2        ,2  ,nil,2 ,3].to_vector(:scale)
+        c= [nil,2        ,"This is a nice example",2   ,2 ,2].to_vector(:scale)
+		ds={'a1'=>a1,'a2'=>a2,'b1'=>b1,'b2'=>b2,'c'=>c}.to_dataset
+        exp=[4,17,27,5,6,5].to_vector(:scale)
+        assert_equal(exp,ds.vector_count_characters)
+        
+    end
+    def test_vector_mean
+		a1=[1  ,2 ,3 ,4  , 5,nil].to_vector(:scale)
+		a2=[10 ,10,20,20 ,20,30].to_vector(:scale)
+		b1=[nil,1 ,1 ,1  ,1 ,2].to_vector(:scale)
+		b2=[2  ,2 ,2 ,nil,2 ,3].to_vector(:scale)
+        c= [nil,2, 4,2   ,2 ,2].to_vector(:scale)
+		ds={'a1'=>a1,'a2'=>a2,'b1'=>b1,'b2'=>b2,'c'=>c}.to_dataset
+		total=ds.vector_mean
+		a=ds.vector_mean(['a1','a2'],1)
+		b=ds.vector_mean(['b1','b2'],1)
+        c=ds.vector_mean(['b1','b2','c'],1)
+		expected_a=[5.5,6,11.5,12,12.5,30].to_vector(:scale)
+		expected_b=[2,1.5,1.5,1,1.5,2.5].to_vector(:scale)
+		expected_c=[nil, 5.0/3,7.0/3,1.5,5.0/3,7.0/3].to_vector(:scale)
+		expected_total=[nil,3.4,6,nil,6.0,nil].to_vector(:scale)
+		assert_equal(expected_a, a)
+		assert_equal(expected_b, b)
+		assert_equal(expected_c, c)
+		assert_equal(expected_total, total)
+	end
+    
+    def test_each_array
+        expected=[[1,'Alex',20,'New York','a,b'], [2,'Claude',23,'London','b,c'], [3,'Peter',25,'London','a'],[4,'Franz', 27,'Paris',nil],[5,'George',5,'Tome','a,b,c']]
+        out=[]
+        @ds.each_array{ |a|
+            out.push(a)
+        }
+        assert_equal(expected,out)
+    end
+    def test_recode
+        @ds['age'].type=:scale
+        @ds.recode!("age") {|c| c['id']*2}
+        expected=[2,4,6,8,10].to_vector(:scale)
+        assert_equal(expected,@ds['age'])
+    end
+    def test_case_as
+        assert_equal({'id'=>1,'name'=>'Alex','city'=>'New York','age'=>20,'a1'=>'a,b'},@ds.case_as_hash(0))
+        assert_equal([5,'George',5,'Tome','a,b,c'],@ds.case_as_array(4))
+
+    end
+    def test_delete_vector
+        @ds.delete_vector('name')
+        assert_equal(%w{id age city a1},@ds.fields)
+        assert_equal(%w{a1 age city id},@ds.vectors.keys.sort)
+    end
+    def test_change_type
+        @ds.col('age').type=:scale
+        assert_equal(:scale,@ds.col('age').type)
+    end
+    def test_split_by_separator_recode
+        @ds.add_vectors_by_split_recode("a1","_")
+        assert_equal(%w{id name age city a1 a1_1 a1_2 a1_3},@ds.fields)
+        assert_equal([1,0,1,nil,1],@ds.col('a1_1').to_a)
+        assert_equal([1,1,0,nil,1],@ds.col('a1_2').to_a)
+        assert_equal([0,1,0,nil,1],@ds.col('a1_3').to_a)
+        assert_equal({'a1_1'=>'a1:a', 'a1_2'=>'a1:b', 'a1_3'=>'a1:c'},@ds.labels)
+    end
+    def test_split_by_separator
+        @ds.add_vectors_by_split("a1","_")
+        assert_equal(%w{id name age city a1 a1_a a1_b a1_c},@ds.fields)
+        assert_equal([1,0,1,nil,1],@ds.col('a1_a').to_a)
+        assert_equal([1,1,0,nil,1],@ds.col('a1_b').to_a)
+        assert_equal([0,1,0,nil,1],@ds.col('a1_c').to_a)
+    end
+    
+    def test_add_case
+        ds=Statsample::Dataset.new({'a'=>[].to_vector, 'b'=>[].to_vector, 'c'=>[].to_vector})
+        ds.add_case([1,2,3])
+        ds.add_case({'a'=>4,'b'=>5,'c'=>6})
+        ds.add_case([[7,8,9],%w{a b c}])
+        assert_equal({'a'=>1,'b'=>2,'c'=>3},ds.case_as_hash(0))
+        assert_equal([4,5,6],ds.case_as_array(1))
+        assert_equal([7,8,9],ds.case_as_array(2))
+        assert_equal(['a','b','c'],ds.case_as_array(3))
+        ds.add_case_array([6,7,1])
+        ds.update_valid_data
+        assert_equal([6,7,1],ds.case_as_array(4))
+        
+    end
+    def test_marshaling
+        ds_marshal=Marshal.load(Marshal.dump(@ds))
+        assert_equal(ds_marshal,@ds)
+    end
+    def test_range
+        v1=[1,2,3,4].to_vector
+        v2=[5,6,7,8].to_vector
+        v3=[9,10,11,12].to_vector
+        ds1=Statsample::Dataset.new({'v1'=>v1,'v2'=>v2,'v3'=>v3}, %w{v3 v2 v1})
+        assert_same(v1,ds1['v1'])
+        ds2=ds1["v2".."v1"]
+        assert_equal(%w{v2 v1},ds2.fields)
+        assert_same(ds1['v1'],ds2['v1'])
+        assert_same(ds1['v2'],ds2['v2'])
+        
+
+    end
+    def test_dup
+        v1=[1,2,3,4].to_vector
+        v2=[5,6,7,8].to_vector
+        ds1=Statsample::Dataset.new({'v1'=>v1,'v2'=>v2}, %w{v2 v1})
+        ds2=ds1.dup
+        assert_equal(ds1,ds2)
+        assert_not_same(ds1,ds2)
+        assert_equal(ds1['v1'],ds2['v1'])
+        assert_not_same(ds1['v1'],ds2['v1'])
+        assert_equal(ds1.fields,ds2.fields)
+        assert_not_same(ds1.fields,ds2.fields)
+        ds1['v1'].type=:scale
+        # dup partial
+        ds3=ds1.dup('v1')
+        ds_exp=Statsample::Dataset.new({'v1'=>v1},%w{v1})
+        assert_equal(ds_exp,ds3)
+        assert_not_same(ds_exp,ds3)
+        assert_equal(ds3['v1'],ds_exp['v1'])
+        assert_not_same(ds3['v1'],ds_exp['v1'])
+        assert_equal(ds3.fields,ds_exp.fields)
+        assert_not_same(ds3.fields,ds_exp.fields)
+        
+        
+        # empty
+        ds3=ds1.dup_empty
+        assert_not_equal(ds1,ds3)
+        assert_not_equal(ds1['v1'],ds3['v1'])
+        assert_equal([],ds3['v1'].data)
+        assert_equal([],ds3['v2'].data)
+        assert_equal(:scale,ds3['v1'].type)
+        assert_equal(ds1.fields,ds2.fields)
+        assert_not_same(ds1.fields,ds2.fields)
+    end
+    def test_from_to
+        assert_equal(%w{name age city}, @ds.from_to("name","city"))
+        assert_raise ArgumentError do
+            @ds.from_to("name","a2")
+        end
+    end
+    def test_dup_only_valid
+        v1=[1,nil,3,4].to_vector(:scale)
+        v2=[5,6,nil,8].to_vector(:scale)
+        v3=[9,10,11,12].to_vector(:scale)
+        ds1=Statsample::Dataset.new({'v1'=>v1,'v2'=>v2,'v3'=>v3})
+        ds2=ds1.dup_only_valid
+        expected=Statsample::Dataset.new({'v1'=>[1,4].to_vector(:scale), 'v2'=> [5,8].to_vector(:scale), 'v3'=>[9, 12].to_vector(:scale)})
+        assert_equal(expected,ds2)
+		assert_equal(expected.vectors.values,Statsample::only_valid(v1,v2,v3))
+    end
+    def test_filter
+        @ds['age'].type=:scale
+        filtered=@ds.filter{|c| c['id']==2 or c['id']==4}
+        expected=Statsample::Dataset.new({'id' => Statsample::Vector.new([2,4]), 'name'=>Statsample::Vector.new(%w{Claude Franz}), 'age'=>Statsample::Vector.new([23,27],:scale),
+        'city'=>Statsample::Vector.new(['London','Paris']),
+        'a1'=>Statsample::Vector.new(['b,c',nil,])}, ['id','name','age','city','a1'])
+        assert_equal(expected,filtered)
+    end                                  
+	def test_filter_field
+		@ds['age'].type=:scale
+        filtered=@ds.filter_field('id') {|c| c['id']==2 or c['id']==4}
+        expected=[2,4].to_vector
+        assert_equal(expected,filtered)
+		
+	end
+    def test_verify
+        name=%w{r1 r2 r3 r4}.to_vector(:nominal)
+        v1=[1,2,3,4].to_vector(:scale)
+        v2=[4,3,2,1].to_vector(:scale)
+        v3=[10,20,30,40].to_vector(:scale)
+        v4=%w{a b a b}.to_vector(:nominal)
+        ds={'v1'=>v1,'v2'=>v2,'v3'=>v3,'v4'=>v4,'id'=>name}.to_dataset
+        ds.fields=%w{v1 v2 v3 v4 id}
+        #Correct
+        t1=create_test("If v4=a, v1 odd") {|r| r['v4']=='b' or (r['v4']=='a' and r['v1']%2==1)}
+        t2=create_test("v3=v1*10")  {|r| r['v3']==r['v1']*10}
+        # Fail!
+        t3=create_test("v4='b'") {|r| r['v4']=='b'}
+        exp1=["1 [1]: v4='b'", "3 [3]: v4='b'"]
+        exp2=["1 [r1]: v4='b'", "3 [r3]: v4='b'"]
+        res=ds.verify(t3,t1,t2)
+        assert_equal(exp1,res)
+        res=ds.verify('id',t1,t2,t3)
+        assert_equal(exp2,res)
+
+    end
+end