daru 0.1.0 → 0.1.1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daru
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2015-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: reportbuilder
@@ -66,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rserve-client
   requirement: !ruby/object:Gem::Requirement
@@ -151,23 +179,26 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: gsl-nmatrix
+  name: rb-gsl
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
-description: "Daru (Data Analysis in RUby) is a library for analysis, manipulation
-  and visualization\nof data.\n\nDaru works with Ruby arrays and NMatrix, thus working
-  seamlessly accross\nruby interpreters, at the same time providing speed for those
-  who need it, while \nmaking working with data super simple and intuitive.\n"
+        version: '1.16'
+description: |
+  Daru (Data Analysis in RUby) is a library for analysis, manipulation and visualization
+  of data. Daru works seamlessly accross interpreters and leverages interpreter-specific
+  optimizations whenever they are available.
+
+  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.
 email:
 - sameer.deshmukh93@gmail.com
 executables: []
@@ -184,16 +215,29 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmarks/TradeoffData.csv
+- benchmarks/dataframe_creation.rb
+- benchmarks/group_by.rb
+- benchmarks/row_access.rb
+- benchmarks/row_assign.rb
+- benchmarks/sorting.rb
+- benchmarks/vector_access.rb
+- benchmarks/vector_assign.rb
+- benchmarks/where_clause.rb
+- benchmarks/where_vs_filter.rb
 - daru.gemspec
 - lib/daru.rb
 - lib/daru/accessors/array_wrapper.rb
 - lib/daru/accessors/dataframe_by_row.rb
-- lib/daru/accessors/dataframe_by_vector.rb
 - lib/daru/accessors/gsl_wrapper.rb
 - lib/daru/accessors/mdarray_wrapper.rb
 - lib/daru/accessors/nmatrix_wrapper.rb
 - lib/daru/core/group_by.rb
+- lib/daru/core/merge.rb
+- lib/daru/core/query.rb
 - lib/daru/dataframe.rb
+- lib/daru/date_time/index.rb
+- lib/daru/date_time/offsets.rb
 - lib/daru/extensions/rserve.rb
 - lib/daru/index.rb
 - lib/daru/io/io.rb
@@ -202,15 +246,19 @@ files:
 - lib/daru/maths/statistics/dataframe.rb
 - lib/daru/maths/statistics/vector.rb
 - lib/daru/monkeys.rb
-- lib/daru/multi_index.rb
 - lib/daru/plotting/dataframe.rb
 - lib/daru/plotting/vector.rb
 - lib/daru/vector.rb
 - lib/daru/version.rb
 - spec/accessors/wrappers_spec.rb
 - spec/core/group_by_spec.rb
+- spec/core/merge_spec.rb
+- spec/core/query_spec.rb
 - spec/daru_spec.rb
 - spec/dataframe_spec.rb
+- spec/date_time/data_spec.rb
+- spec/date_time/index_spec.rb
+- spec/date_time/offsets_spec.rb
 - spec/extensions/rserve_spec.rb
 - spec/fixtures/bank2.dat
 - spec/fixtures/countries.json
@@ -219,6 +267,7 @@ files:
 - spec/fixtures/repeated_fields.csv
 - spec/fixtures/sales-funnel.csv
 - spec/fixtures/scientific_notation.csv
+- spec/fixtures/stock_data.csv
 - spec/fixtures/test_xls.xls
 - spec/index_spec.rb
 - spec/io/io_spec.rb
@@ -227,14 +276,17 @@ files:
 - spec/math/statistics/dataframe_spec.rb
 - spec/math/statistics/vector_spec.rb
 - spec/monkeys_spec.rb
-- spec/multi_index_spec.rb
 - spec/spec_helper.rb
 - spec/vector_spec.rb
 homepage: http://github.com/v0dro/daru
 licenses:
 - BSD-2
 metadata: {}
-post_install_message: 
+post_install_message: "*************************************************************************\nThank
+  you for installing daru!\n\n  oOOOOOo \n ,|    oO\n//|     |\n\\|     |\n `|     |\n
+  \ `-----`\n\n\nHope you love daru! For enhanced interactivity and better visualizations,
+  \nconsider using gnuplotrb and nyaplot with iruby. For statistics use the \nstatsample
+  family.\n\nRead the README for interesting use cases and examples.\n\nCheers!\n*************************************************************************\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -257,8 +309,13 @@ summary: Data Analysis in RUby
 test_files:
 - spec/accessors/wrappers_spec.rb
 - spec/core/group_by_spec.rb
+- spec/core/merge_spec.rb
+- spec/core/query_spec.rb
 - spec/daru_spec.rb
 - spec/dataframe_spec.rb
+- spec/date_time/data_spec.rb
+- spec/date_time/index_spec.rb
+- spec/date_time/offsets_spec.rb
 - spec/extensions/rserve_spec.rb
 - spec/fixtures/bank2.dat
 - spec/fixtures/countries.json
@@ -267,6 +324,7 @@ test_files:
 - spec/fixtures/repeated_fields.csv
 - spec/fixtures/sales-funnel.csv
 - spec/fixtures/scientific_notation.csv
+- spec/fixtures/stock_data.csv
 - spec/fixtures/test_xls.xls
 - spec/index_spec.rb
 - spec/io/io_spec.rb
@@ -275,7 +333,6 @@ test_files:
 - spec/math/statistics/dataframe_spec.rb
 - spec/math/statistics/vector_spec.rb
 - spec/monkeys_spec.rb
-- spec/multi_index_spec.rb
 - spec/spec_helper.rb
 - spec/vector_spec.rb
 has_rdoc: 

data/lib/daru/accessors/dataframe_by_vector.rb

@@ -1,17 +0,0 @@
-module Daru
-  module Accessors
-    class DataFrameByVector
-      def initialize data_frame
-        @data_frame = data_frame
-      end
-
-      def [](*names)
-        @data_frame[*names, :vector]
-      end
-
-      def []=(name, vectors)
-        @data_frame[name, :vector] = vectors
-      end
-    end
-  end
-end

data/lib/daru/multi_index.rb

@@ -1,216 +0,0 @@
-module Daru
-  # Class for holding multi index on Vector and DataFrame.
-  class MultiIndex
-    include Enumerable
-
-    def each(&block)
-      to_a.each(&block)
-      self
-    end
-
-    def map(&block)
-      to_a.map(&block)
-    end
-
-    attr_reader :relation_hash
-    attr_reader :size
-    attr_reader :values
-    
-    # Initialize a MultiIndex by passing a tuple of indexes. The order assigned
-    # to the multi index corresponds to the position of the tuple in the array
-    # of tuples.
-    # 
-    # Although you can create your own hierarchially indexed Vectors and DataFrames,
-    # this class currently contains minimal error checking and is mainly used 
-    # internally for summarizing, splitting and grouping of data.
-    # 
-    # == Arguments
-    # 
-    # * +source+ - The array of arrays from which the multi index is to be created.
-    # 
-    # == Usage
-    # 
-    #   tuples = [:a,:a,:b,:b].zip([:one,:two,:one,:two])
-    #   #=> [[:a, :one], [:a, :two], [:b, :one], [:b, :two]]
-    #   Daru::MultiIndex.new(tuples)
-    def initialize source, values=nil
-      @relation_hash = {}
-      @size = source.size
-      values = Array.new(source.size) { |i| i } if values.nil?
-      create_relation_hash source, values
-      @relation_hash.freeze
-      @values = values
-    end
-
-    def [] *indexes
-      indexes.flatten!
-      location = indexes[0]
-
-      if location.is_a?(Symbol)
-        result = read_relation_hash @relation_hash, indexes, 0
-        return nil if result.nil?
-        result.is_a?(Integer) ? result : Daru::MultiIndex.new(*make_tuples(result))
-      else
-        case location
-        when Integer
-          self[@relation_hash.keys[location]]
-        when Range
-          first = location.first
-          last  = location.last
-
-          hsh = {}
-          first.upto(last) do |index|
-            key = @relation_hash.keys[index]
-            hsh[key] = read_relation_hash(@relation_hash, [key], 0)
-          end
-          Daru::MultiIndex.new(*make_tuples(hsh))
-        end
-      end
-    end
-
-    def + other
-      other.flatten!
-      tuples = to_a
-      raise ArgumentError, "Incomplete tuple #{other}" unless 
-        tuples.all? { |t| t.size == other.size }
-
-      Daru::MultiIndex.new(tuples << (other))
-    end
-
-    def empty?
-      @relation_hash.empty?
-    end
-
-    # Compare two MultiIndex objects for equality based on the contents of their
-    # relation hashes. Does not take object_id into account.
-    def == other
-      return false if size != other.size
-      deep_compare @relation_hash, other.relation_hash
-    end
-
-    # Convert a MultiIndex back to tuples (array of arrays). Will retain the 
-    # order of creation.
-    def to_a
-      make_tuples(@relation_hash)[0]
-    end
-
-    # Completely duplicate a MultiIndex object and its contents.
-    def dup
-      Daru::MultiIndex.new to_a
-    end
-    
-    # Check whether a tuple or identifier number exists in the multi index. 
-    # The argument *tuple* can either a complete or incomplete tuple, or a number.
-    def include? tuple
-      tuple = [tuple] unless tuple.is_a?(Array)
-      tuple.flatten!
-      !!read_relation_hash(@relation_hash, tuple, 0)
-    end
-
-    # Obtain the tuple that correponds with the indentifier number.
-    # 
-    # == Arguments
-    # 
-    # * +key+ - A number for which the tuple is to be obtained.
-    # 
-    # == Usage
-    #   
-    #   mi.key(3) #=> [:a,:two,:baz]
-    def key key
-      tuple = find_tuple_for(@relation_hash, key)
-      tuple.empty? ? nil : tuple
-    end
-
-    def size
-      to_a.size
-    end
-
-   private
-
-    # Deep compare two hashes
-    def deep_compare this, other
-      if this == other
-        return true if this.is_a?(Integer) and other.is_a?(Integer)
-        this.each_key do |key|
-          deep_compare this[key], other[key]
-        end
-      else
-        return false
-      end
-      true
-    end
-
-    # Create tuples out of the relation hash based on the order of the identifier
-    # numbers. Returns an array of arrays containing the tuples and another
-    # containing their corresponding index numbers.
-    def make_tuples relation_hash
-      tuples = []
-      new_vals = []
-      values.each do |number|
-        tuple = find_tuple_for(relation_hash, number)
-        unless tuple.empty?
-          tuples << tuple
-          new_vals << number
-        end
-      end
-      [tuples,new_vals]
-    end
-
-    # Finds and returns a single tuple for a particular identifier number
-    def find_tuple_for relation_hash, number
-      tuple = []
-      search_for_number number, relation_hash, tuple
-      tuple.reverse
-    end
-
-    # Search for a number and store its corresponding tuple in *tuple*. Returns 
-    # true if the number is successfully found.
-    def search_for_number number, relation_hash, tuple
-      found = false
-      relation_hash.each_key do |key|
-        value = relation_hash[key]
-        if value.is_a?(Hash)
-          if search_for_number(number, value, tuple)
-            tuple << key
-            found = true
-          end
-        elsif value == number
-          tuple << key
-          found = true
-        end
-      end
-
-      found
-    end
-
-    # Read the relation hash and return a sub-relation hash or the number to which
-    #   indexes belogs to.
-    def read_relation_hash relation_hash, indexes, index
-      identifier = indexes[index]
-      value      = relation_hash[identifier]
-
-      indexes[index+1].nil? ? value : read_relation_hash(value,indexes,index+1)
-    end
-
-    # Create the relation hash from supplied tuples.
-    def create_relation_hash source, values
-      source.each_with_index do |tuple, idx|
-        populate @relation_hash, tuple, 0, values[idx]
-      end   
-    end
-
-    def populate relation_hash, tuple, index, number
-      identifier = tuple[index]
-
-      if identifier
-        if tuple[index+1] 
-          relation_hash[identifier] ||= {}
-        else
-          relation_hash[identifier] = number
-          return
-        end
-        populate relation_hash[identifier], tuple, index+1, number
-      end
-    end
-  end
-end

data/spec/multi_index_spec.rb

@@ -1,216 +0,0 @@
-require 'spec_helper.rb'
-
-describe Daru::MultiIndex do
-  before(:each) do
-    @index_tuples = [
-      [:a,:one,:bar],
-      [:a,:one,:baz],
-      [:a,:two,:bar],
-      [:a,:two,:baz],
-      [:b,:one,:bar],
-      [:b,:two,:bar],
-      [:b,:two,:baz],
-      [:b,:one,:foo],
-      [:c,:one,:bar],
-      [:c,:one,:baz],
-      [:c,:two,:foo],
-      [:c,:two,:bar]
-    ]
-    @multi_mi = Daru::MultiIndex.new(@index_tuples)
-  end
-
-  context "#initialize" do
-    it "creates 2 layer MultiIndex from tuples" do
-      tuples = [[:a, :one], [:a, :two], [:b, :one], [:b, :two], [:c, :one], [:c, :two]]
-      mi = Daru::MultiIndex.new(tuples)
-      expect(mi.relation_hash).to eq({
-        :a => {
-          :one => 0, 
-          :two => 1
-        },
-        :b => {
-          :one => 2,
-          :two => 3
-        },
-        :c => {
-          :one => 4,
-          :two => 5
-        }
-      })
-    end
-
-    it "creates a triple layer MultiIndex from tuples" do
-      expect(@multi_mi.relation_hash).to eq({
-        :a => {
-          :one => {
-            :bar => 0,
-            :baz => 1
-            },
-          :two => {
-            :bar => 2,
-            :baz => 3
-          }
-        },
-        :b => {
-          :one => {
-            :bar => 4,
-            :foo => 7
-          },
-          :two => {
-            :bar => 5,
-            :baz => 6
-          }
-        },
-        :c => {
-          :one => {
-            :bar => 8,
-            :baz => 9
-          },
-          :two => {
-            :foo => 10,
-            :bar => 11,
-          }
-        }
-      })
-    end
-
-    it "accepts array index values externally" do
-      mi = Daru::MultiIndex.new([
-        [:a,:one,:bar],
-        [:a,:one,:baz],
-        [:a,:two,:bar],
-        [:a,:two,:baz],
-        [:b,:one,:bar]
-      ], [6,3,1,2,9])
-
-      expect(mi[:a,:two,:baz]).to eq(2)
-    end
-  end 
-
-  context "#size" do
-    it "returns size of MultiIndex" do
-      expect(@multi_mi.size).to eq(12)
-    end
-  end
-
-  context "#[]" do
-    it "returns the row number when specifying the complete tuple" do
-      expect(@multi_mi[:a, :one, :baz]).to eq(1)
-    end
-
-    it "returns a MultiIndex when specifying incomplete tuple" do
-      expect(@multi_mi[:b]).to eq(Daru::MultiIndex.new([
-          [:one,:bar],
-          [:two,:bar],
-          [:two,:baz],
-          [:one,:foo]
-        ], [4,5,6,7])
-      )
-
-      expect(@multi_mi[:b, :one]).to eq(Daru::MultiIndex.new([
-          [:bar],
-          [:foo]
-        ], [4,7])
-      )
-      # TODO: Return Daru::Index if a single layer of indexes is present.
-    end
-
-    it "returns a MultiIndex when specifying as an integer index" do
-      expect(@multi_mi[1]).to eq(Daru::MultiIndex.new([
-          [:one,:bar],
-          [:two,:bar],
-          [:two,:baz],
-          [:one,:foo]
-        ],[4,5,6,7])
-      )
-    end
-
-    it "supports numeric Ranges" do
-      expect(@multi_mi[0..1]).to eq(Daru::MultiIndex.new([        
-        [:a,:one,:bar],
-        [:a,:one,:baz],
-        [:a,:two,:bar],
-        [:a,:two,:baz],
-        [:b,:one,:bar],
-        [:b,:two,:bar],
-        [:b,:two,:baz],
-        [:b,:one,:foo]
-      ]))
-    end
-  end
-
-  context "#include?" do
-    it "checks if a completely specified tuple exists" do
-      expect(@multi_mi.include?([:a,:one,:bar])).to eq(true)
-    end
-
-    it "checks if a top layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a])).to eq(true)
-    end
-
-    it "checks if a middle layer incomplete tuple exists" do
-      expect(@multi_mi.include?([:a, :one])).to eq(true)
-    end
-
-    it "checks for non-existence of a tuple" do
-      expect(@multi_mi.include?([:boo])).to eq(false)
-    end
-  end
-
-  context "#key" do
-    it "returns the tuple of the specified number" do
-      expect(@multi_mi.key(3)).to eq([:a,:two,:baz])
-    end
-
-    it "returns nil for non-existent pointer number" do
-      expect(@multi_mi.key(100)).to eq(nil)
-    end
-  end
-
-  context "#to_a" do
-    it "returns tuples as an Array" do
-      expect(@multi_mi.to_a).to eq(@index_tuples)
-    end
-  end
-
-  context "#dup" do
-    it "completely duplicates the object" do
-      duplicate = @multi_mi.dup
-      
-      expect(duplicate)          .to eq(@multi_mi)
-      expect(duplicate.object_id).to_not eq(@multi_mi.object_id)
-    end
-  end
-
-  context "#==" do
-    it "returns false for unequal MultiIndex comparisons" do
-      mi1 = Daru::MultiIndex.new([
-        [:a, :one, :bar],
-        [:a, :two, :baz],
-        [:b, :one, :foo],
-        [:b, :two, :bar]
-        ])
-      mi2 = Daru::MultiIndex.new([
-        [:a, :two, :bar],
-        [:b, :one, :foo],
-        [:a, :one, :baz],
-        [:b, :two, :baz]
-        ])
-
-      expect(mi1 == mi2).to eq(false)
-    end
-  end
-
-  context "#values" do
-    it "returns an array of indices in order" do
-      mi = Daru::MultiIndex.new([
-        [:a, :one, :bar],
-        [:a, :two, :baz],
-        [:b, :one, :foo],
-        [:b, :two, :bar]
-        ], [3,5,1,6])
-
-      expect(mi.values).to eq([3,5,1,6])
-    end
-  end
-end