davidrichards-data_frame 0.0.13 → 0.0.14

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 0
-:patch: 13
+:patch: 14

data/lib/data_frame.rb

@@ -212,6 +212,11 @@ class DataFrame
     self
   end
   
+  def filter(as=Array, &block)
+    new_data_frame = self.clone
+    new_data_frame.filter!(as, &block)
+  end
+  
   def infer_class(obj)
     obj = obj.to_s.classify.constantize if obj.is_a?(Symbol)
     obj = obj.classify.constantize if obj.is_a?(String)
@@ -235,7 +240,7 @@ class DataFrame
     elsif as == Array
       row
     else
-      as.new(row)
+      as.new(*row)
     end
   end
   protected :cast_row
@@ -253,5 +258,53 @@ class DataFrame
     end
     new_data_frame
   end
+  
+  # A weird name.  This creates a column for every category in a column
+  # and marks each row by its value 
+  def j_binary_ize!(*columns)
+    columns.each do |col|
+      values = render_column(col.to_underscore_sym)
+      values.categories.each do |category|
+        self.append!(category, values.map{|e| e == category ? true : false})
+      end
+    end
+  end
+  
+  # Adds a unique column to the table
+  def append!(column_name, value=nil)
+    raise ArgumentError, "Can't have duplicate column names" if self.labels.include?(column_name)
+    self.labels << column_name.to_underscore_sym
+    if value.is_a?(Array)
+      self.items.each_with_index do |item, i|
+        item << value[i]
+      end
+    else
+      self.items.each do |item|
+        item << value
+      end
+    end
+    # Because we are tainting the sub arrays, the TaintableArray doesn't know it's been changed.
+    self.items.taint
+  end
+  
+  def filter_by_category(hash)
+    new_data_frame = self.dup
+    hash.each do |key, value|
+      key = key.to_underscore_sym
+      next unless self.labels.include?(key)
+      value = [value] unless value.is_a?(Array) or value.is_a?(Range)
+      new_data_frame.filter!(:hash) {|row| value.include?(row[key])}
+    end
+    new_data_frame
+  end
+
+  def filter_by_category!(hash)
+    hash.each do |key, value|
+      key = key.to_underscore_sym
+      next unless self.labels.include?(key)
+      value = [value] unless value.is_a?(Array) or value.is_a?(Range)
+      self.filter!(:hash) {|row| value.include?(row[key])}
+    end
+  end
     
 end

data/lib/data_frame/transposable_array.rb

@@ -6,6 +6,7 @@ class TransposableArray < CallbackArray
   
   orig_transpose = instance_method(:transpose)
   define_method(:transpose) {
+    self.untaint
     @transpose ||= orig_transpose.bind(self).call
   }
   

data/spec/data_frame_spec.rb

@@ -171,10 +171,83 @@ describe DataFrame do
       @df.add [5, 6, 7, 8]
     end
     
-    it "should be able to filter a data frame with a block" do
+    it "should be able to filter a data frame with a block using an OpenStruct for each row" do
       @df.filter!(:open_struct) {|row| row.these == 5}
       @df.items.should eql([[5, 6, 7, 8]])
     end
+    
+    it "should be able to filter a data frame with a block using a Hash for each row" do
+      @df.filter!(:hash) {|row| row[:these] == 5}
+      @df.items.should eql([[5, 6, 7, 8]])
+    end
+    
+    S4 = Struct.new(:one, :two, :three, :four)
+    it "should be able to filter a data frame with a block using another class that uses the row as input" do
+      @df.filter!(S4) {|row| row.one == 5}
+      @df.items.should eql([[5, 6, 7, 8]])
+    end
+    
+    it "should be able to filter a data frame with a block using an array for each row" do
+      @df.filter! {|row| row.first == 5}
+      @df.items.should eql([[5, 6, 7, 8]])
+    end
+    
+    it "should be able to do fancy things with the row as the filter" do
+      @df.filter! {|row| row.sum > 10}
+      @df.items.should eql([[5, 6, 7, 8]])
+    end
+    
+    it "should be able to generate a new data frame with filter" do
+      new_df = @df.filter(:open_struct) {|row| row.these == 5}
+      new_df.items.should eql([[5, 6, 7, 8]])
+      @df.items.should eql([[1, 2, 3, 4], [5, 6, 7, 8]])
+    end
+    
+  end
+  
+  context "filter_by_category" do
+    
+    before do
+      @df = DataFrame.new(:weather, :date)
+
+      (1..31).each do |i|
+        @df.add [(i % 3 == 1) ? :fair : :good, Date.parse("07/#{i}/2009")]
+      end
+
+      @d1 = Date.parse("07/15/2009")
+      @d2 = Date.parse("07/31/2009")
+
+    end
+    
+    it "should be able to filter by category" do
+      filtered = @df.filter_by_category(:weather => :good)
+      filtered.weather.uniq.should eql([:good])
+      @df.weather.uniq.should be_include(:fair)
+    end
+    
+    it "should be able to manage ranges for filter values" do
+      filtered = @df.filter_by_category(:date => (@d1..@d2))
+      filtered.date.should_not be_include(Date.parse("07/01/2009"))
+      filtered.date.should_not be_include(Date.parse("07/14/2009"))
+      filtered.date.should be_include(Date.parse("07/15/2009"))
+      filtered.date.should be_include(Date.parse("07/31/2009"))
+      @df.date.should be_include(Date.parse("07/01/2009"))
+    end
+    
+    it "should be able to take an array of values to filter with" do
+      filtered = @df.filter_by_category(:date => [@d1, @d2])
+      filtered.date.should_not be_include(Date.parse("07/01/2009"))
+      filtered.date.should be_include(Date.parse("07/15/2009"))
+      filtered.date.should be_include(Date.parse("07/31/2009"))
+    end
+    
+    it "should have a destructive version" do
+      @df.filter_by_category!(:date => [@d1, @d2])
+      @df.date.should_not be_include(Date.parse("07/01/2009"))
+      @df.date.should be_include(Date.parse("07/15/2009"))
+      @df.date.should be_include(Date.parse("07/31/2009"))
+    end
+    
   end
   
   context "subset_from_columns" do
@@ -191,4 +264,43 @@ describe DataFrame do
       new_data_frame.these.should eql([1,5])
     end
   end
+  
+  it "should be able to j_binary_ize! a column, taking its categories and creating a column for each" do
+    df = DataFrame.new(:observations)
+    df.add [:many]
+    df.add [:fine]
+    df.add [:things]
+    df.add [:are]
+    df.add [:available]
+    df.j_binary_ize!(:observations)
+    df.many.should eql([true, false, false, false, false])
+    df.fine.should eql([false, true, false, false, false])
+    df.things.should eql([false, false, true, false, false])
+    df.are.should eql([false, false, false, true, false])
+    df.available.should eql([false, false, false, false, true])
+    df.observations.should eql([:many, :fine, :things, :are, :available])
+  end
+  
+  context "append!" do
+    
+    before do
+      @df.add [1,2,3,4]
+      @df.add [5, 6, 7, 8]
+    end
+    
+    it "should be able to append an array of values to the data frame" do
+      @df.append!(:new_column, [5,5])
+      @df.new_column.should eql([5,5])
+    end
+    
+    it "should be able to append a default value to the data frame" do
+      @df.append!(:new_column, :value)
+      @df.new_column.should eql([:value, :value])
+    end
+    
+    it "should use nil as the default value" do
+      @df.append!(:new_column)
+      @df.new_column.should eql([nil, nil])
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: davidrichards-data_frame
 version: !ruby/object:Gem::Version 
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors: 
 - David Richards
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-16 00:00:00 -07:00
+date: 2009-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency