daru 0.1.0 → 0.1.1

data/benchmarks/vector_access.rb

@@ -0,0 +1,31 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru'
+
+df = Daru::DataFrame.new({
+  a: 10000.times.map { rand },
+  b: 10000.times.map { rand },
+  c: 10000.times.map { rand }
+})
+
+Benchmark.bm do |x|
+  x.report("Single Vector access") do
+    df[:a]
+  end
+
+  x.report("Access as range") do
+    df[:a..:c]
+  end
+
+  x.report("Access with commas") do
+    df[:a, :c]
+  end
+end
+
+# ======== Benchmarks =======
+#
+#                         user     system      total        real
+# Single Vector access  0.000000   0.000000   0.000000 (  0.000012)
+# Access as range       0.090000   0.000000   0.090000 (  0.084584)
+# Access with commas    0.050000   0.000000   0.050000 (  0.051951)

data/benchmarks/vector_assign.rb

@@ -0,0 +1,42 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru'
+
+df = Daru::DataFrame.new({
+  a: 100000.times.map { rand },
+  b: 100000.times.map { rand },
+  c: 100000.times.map { rand }
+})
+
+index = Daru::Index.new((0...100000).to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("Assign new vector as Array") do
+    df[:d] = 100000.times.map { rand }
+  end
+
+  x.report("Reassign same vector as Array") do
+    df[:a] = 100000.times.map { rand }
+  end
+
+  x.report("Assign new Vector as Daru::Vector") do
+    df[:e] = Daru::Vector.new(100000.times.map { rand })
+  end
+
+  x.report("Reassign same Vector as Daru::Vector") do
+    df[:b] = Daru::Vector.new(100000.times.map { rand })
+  end
+
+  x.report("Reassgin differently indexed Daru::Vector") do
+    df[:b] = Daru::Vector.new(100000.times.map { rand }, index: index)
+  end
+end
+
+#                           ===== Benchmarks =====
+#                                             user     system      total        real
+# Assign new vector as Array                0.370000   0.000000   0.370000 (0.364515)
+# Reassign same vector as Array             0.470000   0.000000   0.470000 (0.471408)
+# Assign new Vector as Daru::Vector         0.940000   0.000000   0.940000 (0.947879)
+# Reassign same Vector as Daru::Vector      0.760000   0.020000   0.780000 (0.769969)
+# Reassgin differently indexed Daru::Vector <Too embarassingly slow.>

data/benchmarks/where_clause.rb

@@ -0,0 +1,48 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru'
+
+df = Daru::DataFrame.new({
+  a: 100000.times.map { |i| i },
+  b: 100000.times.map { |i| i },
+  c: 100000.times.map { |i| i }
+}, index: Daru::Index.new(100000.times.map.to_a.shuffle))
+
+puts "Benchmarking DataFrame#where\n"
+Benchmark.bm do |x|
+  x.report("Basic one liner") do
+    df.where(df[:a].mt(2341))
+  end
+
+  x.report("Little complex statement") do
+    df.where(df[:a].lt(235) | df[:b].eq(2341) | df[:c].in([35,355,22]))
+  end
+end
+
+puts "Benchmarking Vector#where\n"
+v = Daru::Vector.new(
+  100000.times.map { |i| i }, index: 100000.times.map.to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("Basic one liner") do
+    v.where(v.mteq(1000))
+  end
+
+  x.report("Little complex statement") do
+    v.where(v.lt(235) & v.eq(2341) | v.in([23,511,55]))
+  end
+end
+
+#                     ====== Benchmarks ======
+# 
+# Benchmarking DataFrame#where
+#
+#                             user     system      total      real
+# Basic one liner           0.700000   0.000000   0.700000 (0.703532)
+# Little complex statement  0.120000   0.000000   0.120000 (0.121765)
+#
+# Benchmarking Vector#where
+#                             user     system      total      real
+# Basic one liner           0.240000   0.000000   0.240000 (0.245787)
+# Little complex statement  0.100000   0.000000   0.100000 (0.094423)

data/benchmarks/where_vs_filter.rb

@@ -0,0 +1,28 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'benchmark'
+require 'daru'
+
+df = Daru::DataFrame.new({
+  a: [1,2,3,4,5,6]*100,
+  b: ['a','b','c','d','e','f']*100,
+  c: [11,22,33,44,55,66]*100
+}, index: (1..600).to_a.shuffle)
+
+Benchmark.bm do |x|
+  x.report("where") do
+    df.where(df[:a].eq(2) | df[:c].eq(55))
+  end
+
+  x.report("filter_rows") do
+    df.filter(:row) do |r|
+      r[:a] == 2 or r[:c] == 55
+    end
+  end
+end
+
+#             ===== Benchmarks =====
+# 
+#                user     system      total        real
+# where        0.000000   0.000000   0.000000 (  0.002575)
+# filter_rows  0.210000   0.000000   0.210000 (  0.205403)

data/daru.gemspec

@@ -5,11 +5,11 @@ require 'daru/version.rb'
 
 Daru::DESCRIPTION = <<MSG
 Daru (Data Analysis in RUby) is a library for analysis, manipulation and visualization
-of data.
+of data. Daru works seamlessly accross interpreters and leverages interpreter-specific
+optimizations whenever they are available.
 
-Daru works with Ruby arrays and NMatrix, thus working seamlessly accross
-ruby interpreters, at the same time providing speed for those who need it, while 
-making working with data super simple and intuitive.
+It is the default data storage gem for all the statsample gems (glm, timeseries, etc.)
+and can be used with many others like mixed_models, gnuplotrb, nyaplot and iruby.
 MSG
 
 Gem::Specification.new do |spec|
@@ -27,16 +27,40 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.post_install_message = <<-EOF
+*************************************************************************
+Thank you for installing daru!
+
+  oOOOOOo 
+ ,|    oO
+//|     |
+\\|     |
+ `|     |
+  `-----`
+
+
+Hope you love daru! For enhanced interactivity and better visualizations, 
+consider using gnuplotrb and nyaplot with iruby. For statistics use the 
+statsample family.
+
+Read the README for interesting use cases and examples.
+
+Cheers!
+*************************************************************************
+EOF
+
   spec.add_runtime_dependency 'reportbuilder', '~> 1.4'
   spec.add_runtime_dependency 'spreadsheet', '~> 1.0.3'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'rserve-client', '~> 0.3'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'awesome_print'
   spec.add_development_dependency 'nyaplot', '~> 0.1.5'
   spec.add_development_dependency 'nmatrix', '~> 0.1.0'
   spec.add_development_dependency 'distribution', '~> 0.7'
-  spec.add_development_dependency 'gsl-nmatrix', '~>1.17'
+  spec.add_development_dependency 'rb-gsl', '~>1.16'
 end

data/lib/daru.rb

@@ -3,6 +3,31 @@ def jruby?
 end
 
 module Daru
+  DAYS_OF_WEEK = {
+    'SUN' => 0,
+    'MON' => 1,
+    'TUE' => 2,
+    'WED' => 3,
+    'THU' => 4,
+    'FRI' => 5,
+    'SAT' => 6
+  }
+
+  MONTH_DAYS = {
+    1 => 31,
+    2 => 28,
+    3 => 31,
+    4 => 30,
+    5 => 31,
+    6 => 30,
+    7 => 31,
+    8 => 31,
+    9 => 30,
+    10 => 31,
+    11 => 30,
+    12 => 31
+  }
+  
   SPLIT_TOKEN = ','
   class << self
     @@lazy_update = false
@@ -42,9 +67,13 @@ require 'reportbuilder'
 
 require 'daru/version.rb'
 require 'daru/index.rb'
-require 'daru/multi_index.rb'
 require 'daru/vector.rb'
 require 'daru/dataframe.rb'
 require 'daru/monkeys.rb'
 
 require 'daru/core/group_by.rb'
+require 'daru/core/query.rb'
+require 'daru/core/merge.rb'
+
+require 'daru/date_time/offsets.rb'
+require 'daru/date_time/index.rb'

data/lib/daru/accessors/array_wrapper.rb

@@ -45,8 +45,8 @@ module Daru
         set_size
       end
 
-      def index key
-        @data.index key
+      def index *args, &block
+        @data.index(*args, &block)
       end
 
       def << element

data/lib/daru/accessors/nmatrix_wrapper.rb

@@ -34,6 +34,8 @@ module Daru
       end
  
       def []= index, value
+        raise ArgumentError, "Index #{index} does not exist" if 
+          index > @size and index < @data.size
         resize     if index >= @data.size
         @size += 1 if index == @size
         
@@ -42,7 +44,7 @@ module Daru
       end 
  
       def == other
-        @data == other and @size == other.size
+        @data[0...@size] == other[0...@size] and @size == other.size
       end
  
       def delete_at index
@@ -59,8 +61,6 @@ module Daru
       def << element
         resize if @size >= @data.size
         self[@size] = element
-
-        @size += 1
       end
  
       def to_a
@@ -74,7 +74,7 @@ module Daru
       def resize size = @size*2
         raise ArgumentError, "Size must be greater than current size" if size < @size
 
-        @data = NMatrix.new [size], @data.to_a
+        @data = NMatrix.new [size], @data.to_a, dtype: @nm_dtype
       end
 
       def mean
@@ -90,11 +90,11 @@ module Daru
       end
 
       def max
-        @data.max
+        @data[0...@size].max
       end
 
       def min
-        @data.min
+        @data[0...@size].min
       end
     end
   end

data/lib/daru/core/group_by.rb

@@ -4,11 +4,19 @@ module Daru
 
       attr_reader :groups
 
+      # Iterate over each group created by group_by. A DataFrame is yielded in
+      # block.
+      def each_group &block
+        groups.keys.each do |k|
+          yield get_group(k)
+        end
+      end
+
       def initialize context, names
         @groups = {}
         @non_group_vectors = context.vectors.to_a - names
         @context = context
-        vectors = names.map { |vec| context.vector[vec].to_a }
+        vectors = names.map { |vec| context[vec].to_a }
         tuples  = vectors[0].zip(*vectors[1..-1])
         keys    = tuples.uniq.sort
 
@@ -18,35 +26,92 @@ module Daru
         @groups.freeze
       end
 
+      # Get a Daru::Vector of the size of each group.
       def size
         index = 
         if multi_indexed_grouping?
-          Daru::MultiIndex.new symbolize(@groups.keys)
+          Daru::MultiIndex.from_tuples @groups.keys
         else
-          Daru::Index.new symbolize(@groups.keys.flatten)
+          Daru::Index.new @groups.keys.flatten
         end
 
         values = @groups.values.map { |e| e.size }
         Daru::Vector.new(values, index: index, name: :size)
       end
 
+      # Get the first group
       def first
         head(1)
       end
 
+      # Get the last group
       def last
         tail(1)
       end
 
+      # Get the top 'n' groups
+      # @param quantity [Fixnum] (5) The number of groups.
+      # @example Usage of head
+      #   df = Daru::DataFrame.new({
+      #     a: %w{foo bar foo bar   foo bar foo foo},
+      #     b: %w{one one two three two two one three},
+      #     c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],
+      #     d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
+      #   })
+      #   df.group_by([:a, :b]).head(1)
+      #   # => 
+      #   # #<Daru::DataFrame:82745170 @name = d7003f75-5eb9-4967-9303-c08dd9160224 @size = 6>
+      #   #                     a          b          c          d 
+      #   #          1        bar        one          2         22 
+      #   #          3        bar      three          1         44 
+      #   #          5        bar        two          6         66 
+      #   #          0        foo        one          1         11 
+      #   #          7        foo      three          8         88 
+      #   #          2        foo        two          3         33  
       def head quantity=5
         select_groups_from :first, quantity
       end
 
+      # Get the bottom 'n' groups
+      # @param quantity [Fixnum] (5) The number of groups.
+      # @example Usage of tail
+      #   df = Daru::DataFrame.new({
+      #     a: %w{foo bar foo bar   foo bar foo foo},
+      #     b: %w{one one two three two two one three},
+      #     c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],
+      #     d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
+      #   })
+      #   # df.group_by([:a, :b]).tail(1)
+      #   # => 
+      #   # #<Daru::DataFrame:82378270 @name = 0623db46-5425-41bd-a843-99baac3d1d9a @size = 6>
+      #   #                     a          b          c          d 
+      #   #          1        bar        one          2         22 
+      #   #          3        bar      three          1         44 
+      #   #          5        bar        two          6         66 
+      #   #          6        foo        one          3         77 
+      #   #          7        foo      three          8         88 
+      #   #          4        foo        two          3         55
       def tail quantity=5
         select_groups_from :last, quantity
       end
 
       # Calculate mean of numeric groups, excluding missing values.
+      # @example Usage of mean
+      #   df = Daru::DataFrame.new({
+      #     a: %w{foo bar foo bar   foo bar foo foo},
+      #     b: %w{one one two three two two one three},
+      #     c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],
+      #     d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
+      #   df.group_by([:a, :b]).mean
+      #   # => 
+      #   # #<Daru::DataFrame:81097450 @name = 0c32983f-3e06-451f-a9c9-051cadfe7371 @size = 6>
+      #   #                         c          d 
+      #   # ["bar", "one"]          2         22 
+      #   # ["bar", "three"]        1         44 
+      #   # ["bar", "two"]          6         66 
+      #   # ["foo", "one"]        2.0       44.0 
+      #   # ["foo", "three"]        8         88 
+      #   # ["foo", "two"]        3.0       44.0 
       def mean
         apply_method :numeric, :mean
       end
@@ -61,6 +126,24 @@ module Daru
         apply_method :numeric, :sum
       end
 
+      # Count groups, excludes missing values.
+      # @example Using count
+      #   df = Daru::DataFrame.new({    
+      #     a: %w{foo bar foo bar   foo bar foo foo},      
+      #     b: %w{one one two three two two one three},      
+      #     c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],      
+      #     d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]      
+      #   })        
+      #   df.group_by([:a, :b]).count
+      #   # => 
+      #   # #<Daru::DataFrame:76900210 @name = 7b9cf55d-17f8-48c7-b03a-2586c6e5ec5a @size = 6>
+      #   #                           c          d 
+      #   # ["bar", "one"]            1          1 
+      #   # ["bar", "two"]            1          1 
+      #   # ["bar", "three"]          1          1 
+      #   # ["foo", "one"]            2          2 
+      #   # ["foo", "three"]          1          1 
+      #   # ["foo", "two"]            2          2 
       def count
         width = @non_group_vectors.size
         Daru::DataFrame.new([size]*width, order: @non_group_vectors)
@@ -83,6 +166,21 @@ module Daru
       end
 
       # Returns one of the selected groups as a DataFrame.
+      # @param group [Array] The group that is to be selected from those grouped.
+      #
+      # @example Getting a group
+      #
+      #   df = Daru::DataFrame.new({
+      #         a: %w{foo bar foo bar   foo bar foo foo},
+      #         b: %w{one one two three two two one three},
+      #         c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],
+      #         d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
+      #       })
+      #   df.group_by([:a, :b]).get_group ['bar','two']
+      #   #=> 
+      #   ##<Daru::DataFrame:83258980 @name = 687ee3f6-8874-4899-97fa-9b31d84fa1d5 @size = 1>
+      #   #                    a          b          c          d 
+      #   #         5        bar        two          6         66
       def get_group group
         indexes   = @groups[group]
         elements  = []
@@ -96,7 +194,8 @@ module Daru
         indexes.each do |idx|
           rows << transpose[idx]
         end
-        Daru::DataFrame.rows(rows, index: @context.index[indexes], order: @context.vectors)
+        Daru::DataFrame.rows(
+          rows, index: @context.index[indexes], order: @context.vectors)
       end
 
      private 
@@ -123,28 +222,24 @@ module Daru
         @groups.each do |group, indexes|
           single_row = []
           @non_group_vectors.each do |ngvector|
-            vector = @context.vector[ngvector]
-            if method_type == :numeric and vector.type == :numeric
-              slice = vector[*indexes]
-
+            vec = @context[ngvector]
+            if method_type == :numeric and vec.type == :numeric
+              slice = vec[*indexes]
               single_row << (slice.is_a?(Numeric) ? slice : slice.send(method))
-              order << ngvector
             end
           end 
 
           rows << single_row
         end
 
-        index = symbolize @groups.keys
-        index = multi_index ? Daru::MultiIndex.new(index) : Daru::Index.new(index.flatten)
-        order = symbolize order
-        order = 
-        if order.all?{ |e| e.is_a?(Array) }
-          Daru::MultiIndex.new(order)
-        else
-          Daru::Index.new(order)
+        @non_group_vectors.each do |ngvec|
+          order << ngvec if
+            (method_type == :numeric and @context[ngvec].type == :numeric)
         end
 
+        index = @groups.keys
+        index = multi_index ? Daru::MultiIndex.from_tuples(index) : Daru::Index.new(index.flatten)
+        order = Daru::Index.new(order)
         Daru::DataFrame.new(rows.transpose, index: index, order: order)
       end
 
@@ -160,20 +255,6 @@ module Daru
         indexes
       end
 
-      def symbolize arry
-        symbolized_arry =
-        if arry.all? { |e| e.is_a?(Array) }
-          arry.map do |sub_arry|
-            sub_arry.map do |e|
-              e.is_a?(Numeric) ? e : e.to_sym
-            end
-          end
-        else
-          arry.map { |e| e.is_a?(Numeric) ? e : e.to_sym }
-        end
-        symbolized_arry
-      end
-
       def multi_indexed_grouping?
         @groups.keys[0][1] ? true : false
       end