daru 0.2.2 → 0.3

data/lib/daru/date_time/offsets.rb

@@ -111,6 +111,14 @@ module Daru
       def - date_time
         date_time - @n*multiplier
       end
+
+      def ==(other_obj)
+        other_obj.is_a?(Tick) && period == other_obj.period
+      end
+
+      def period
+        @n * multiplier
+      end
     end
 
     # Create a seconds offset

data/lib/daru/formatters/table.rb

@@ -13,13 +13,10 @@ module Daru
         @row_headers = [''] * @data.to_a.size if @row_headers.empty?
       end
 
-      DEFAULT_SPACING = 10
-      DEFAULT_THRESHOLD = 15
-
       def format threshold=nil, spacing=nil
-        rows = build_rows(threshold || DEFAULT_THRESHOLD)
+        rows = build_rows(threshold || Daru.max_rows)
 
-        formatter = construct_formatter rows, spacing || DEFAULT_SPACING
+        formatter = construct_formatter rows, spacing || Daru.spacing
 
         rows.map { |r| formatter % r }.join("\n")
       end

data/lib/daru/io/io.rb

@@ -39,16 +39,12 @@ module Daru
       # Functions for loading/writing Excel files.
 
       def from_excel path, opts={}
-        optional_gem 'spreadsheet', '~>1.1.1'
         opts = {
-          worksheet_id: 0
+          worksheet_id: 0,
+          row_id: 0
         }.merge opts
 
-        worksheet_id = opts[:worksheet_id]
-        book         = Spreadsheet.open path
-        worksheet    = book.worksheet worksheet_id
-        headers      = ArrayHelper.recode_repeated(worksheet.row(0)).map(&:to_sym)
-
+        worksheet, headers = read_from_excel(path, opts)
         df = Daru::DataFrame.new({})
         headers.each_with_index do |h,i|
           col = worksheet.column(i).to_a
@@ -59,6 +55,18 @@ module Daru
         df
       end
 
+      def read_from_excel path, opts
+        optional_gem 'spreadsheet', '~>1.1.1'
+
+        worksheet_id = opts[:worksheet_id]
+        row_id       = opts[:row_id]
+        book         = Spreadsheet.open path
+        worksheet    = book.worksheet worksheet_id
+        headers      = ArrayHelper.recode_repeated(worksheet.row(row_id)).map(&:to_sym)
+
+        [worksheet, headers]
+      end
+
       def dataframe_write_excel dataframe, path, _opts={}
         book   = Spreadsheet::Workbook.new
         sheet  = book.create_worksheet
@@ -231,7 +239,7 @@ module Daru
       def from_csv_hash(path, opts)
         csv_as_arrays =
           ::CSV
-          .parse(open(path), opts)
+          .parse(open(path), **opts)
           .tap { |c| yield c if block_given? }
           .to_a
         headers       = ArrayHelper.recode_repeated(csv_as_arrays.shift)

data/lib/daru/vector.rb

@@ -444,6 +444,27 @@ module Daru
       Daru::Core::Query.vector_where self, bool_array
     end
 
+    # Return a new vector based on the contents of a boolean array and &block.
+    #
+    # @param bool_array [Daru::Core::Query::BoolArray, Array<TrueClass, FalseClass>, &block] The
+    #   collection containing the true of false values. Each element in the Vector
+    #   corresponding to a `true` in the bool_array will be returned along with it's
+    #   index. The &block may contain manipulative functions for the Vector elements.
+    #
+    # @return [Daru::Vector]
+    #
+    # @example Usage of #apply_where.
+    #   dv = Daru::Vector.new ['3 days', '5 weeks', '2 weeks']
+    #   dv = dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" }
+    #   # =>
+    #   ##<Daru::Vector(3)>
+    #   #  0   3 days
+    #   #  1   35 days
+    #   #  2   14 days
+    def apply_where bool_array, &block
+      Daru::Core::Query.vector_apply_where self, bool_array, &block
+    end
+
     def head q=10
       self[0..(q-1)]
     end
@@ -453,6 +474,11 @@ module Daru
       self[start..(size-1)]
     end
 
+    def last q=1
+      # The Enumerable mixin dose not provide the last method.
+      tail(q)
+    end
+
     def empty?
       @index.empty?
     end
@@ -1252,6 +1278,22 @@ module Daru
       Daru::DataFrame.new ps
     end
 
+    # Returns an array of either none or integer values, indicating the
+    # +regexp+ matching with the given array.
+    #
+    # @param regexp [Regexp] A regular matching expression. For example, +/weeks/+.
+    #
+    # @return [Array] Containing either +nil+ or integer values, according to the match with the given +regexp+
+    #
+    # @example
+    #   dv = Daru::Vector.new(['3 days', '5 weeks', '2 weeks'])
+    #   dv.match(/weeks/)
+    #
+    #   # => [false, true, true]
+    def match(regexp)
+      @data.map { |value| !!(value =~ regexp) }
+    end
+
     # Creates a new vector consisting only of non-nil data
     #
     # == Arguments

data/lib/daru/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.3'.freeze
 end

data/spec/accessors/gsl_wrapper_spec.rb

@@ -1,50 +1,53 @@
-describe Daru::Accessors::GSLWrapper do
-  before :each do
-    @stub_context = Object.new
-    @gsl_wrapper = Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6], @stub_context)
-  end
+if Daru.has_gsl?
+  describe Daru::Accessors::GSLWrapper do
+    before :each do
+      @stub_context = Object.new
+      @gsl_wrapper = Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6], @stub_context)
+    end
 
-  context ".new" do
-    it "actually creates a GSL Vector" do
-      expect(@gsl_wrapper.data.class).to eq(GSL::Vector)
+    context ".new" do
+      it "actually creates a GSL Vector" do
+        expect(@gsl_wrapper.data.class).to eq(GSL::Vector)
+      end
     end
-  end
 
-  context "#mean" do
-    it "computes mean" do
-      expect(@gsl_wrapper.mean).to eq(3.5)
+    context "#mean" do
+      it "computes mean" do
+        expect(@gsl_wrapper.mean).to eq(3.5)
+      end
     end
-  end
 
-  context "#map!" do
-    it "destructively maps" do
-      expect(@gsl_wrapper.map! { |a| a += 1 }).to eq(
-        Daru::Accessors::GSLWrapper.new([2,3,4,5,6,7], @stub_context)
-      )
+    context "#map!" do
+      it "destructively maps" do
+        expect(@gsl_wrapper.map! { |a| a += 1 }).to eq(
+          Daru::Accessors::GSLWrapper.new([2,3,4,5,6,7], @stub_context)
+        )
+      end
     end
-  end
 
-  context "#delete_at" do
-    it "deletes at key" do
-      expect(@gsl_wrapper.delete_at(2)).to eq(3)
+    context "#delete_at" do
+      it "deletes at key" do
+        expect(@gsl_wrapper.delete_at(2)).to eq(3)
 
-      expect(@gsl_wrapper).to eq(
-        Daru::Accessors::GSLWrapper.new([1,2,4,5,6], @stub_context)
-      )
+        expect(@gsl_wrapper).to eq(
+          Daru::Accessors::GSLWrapper.new([1,2,4,5,6], @stub_context)
+        )
+      end
     end
-  end
 
-  context "#index" do
-    it "returns index of value" do
-      expect(@gsl_wrapper.index(3)).to eq(2)
+    context "#index" do
+      it "returns index of value" do
+        expect(@gsl_wrapper.index(3)).to eq(2)
+      end
     end
-  end
 
-  context "#push" do
-    it "appends element" do
-      expect(@gsl_wrapper.push(15)).to eq(
-        Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6,15], @stub_context)
-      )
+    context "#push" do
+      it "appends element" do
+        expect(@gsl_wrapper.push(15)).to eq(
+          Daru::Accessors::GSLWrapper.new([1,2,3,4,5,6,15], @stub_context)
+        )
+      end
     end
   end
 end
+

data/spec/accessors/nmatrix_wrapper_spec.rb

@@ -1,32 +1,35 @@
 require 'spec_helper.rb'
 
-describe Daru::Accessors::NMatrixWrapper do
-  before :each do
-    stub_context = Object.new
-    @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
-  end
+if Daru.has_nmatrix?
+  describe Daru::Accessors::NMatrixWrapper do
+    before :each do
+      stub_context = Object.new
+      @nm_wrapper = Daru::Accessors::NMatrixWrapper.new([1,2,3,4,5], stub_context, :float32)
+    end
 
-  it "checks for actual NMatrix creation" do
-    expect(@nm_wrapper.data.class).to eq(NMatrix)
-  end
+    it "checks for actual NMatrix creation" do
+      expect(@nm_wrapper.data.class).to eq(NMatrix)
+    end
 
-  it "checks the actual size of the NMatrix object" do
-    expect(@nm_wrapper.data.size).to eq(10)
-  end
+    it "checks the actual size of the NMatrix object" do
+      expect(@nm_wrapper.data.size).to eq(10)
+    end
 
-  it "checks that @size is the number of elements in the vector" do
-    expect(@nm_wrapper.size).to eq(5)
-  end
+    it "checks that @size is the number of elements in the vector" do
+      expect(@nm_wrapper.size).to eq(5)
+    end
 
-  it "checks for underlying NMatrix data type" do
-    expect(@nm_wrapper.data.dtype).to eq(:float32)
-  end
+    it "checks for underlying NMatrix data type" do
+      expect(@nm_wrapper.data.dtype).to eq(:float32)
+    end
 
-  it "resizes" do
-    @nm_wrapper.resize(100)
+    it "resizes" do
+      @nm_wrapper.resize(100)
 
-    expect(@nm_wrapper.size).to eq(5)
-    expect(@nm_wrapper.data.size).to eq(100)
-    expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
+      expect(@nm_wrapper.size).to eq(5)
+      expect(@nm_wrapper.data.size).to eq(100)
+      expect(@nm_wrapper.data).to eq(NMatrix.new [100], [1,2,3,4,5])
+    end
   end
 end
+

data/spec/core/merge_spec.rb

@@ -112,7 +112,7 @@ describe Daru::DataFrame do
       expect(@left.join(@right, how: :outer, on: [:name])).to eq(answer)
     end
 
-    it "performs a left outer join", focus: true do
+    it "performs a left outer join" do
       answer = Daru::DataFrame.new({
         :id_1 => [2,3,1,4],
         :name => ["Monkey", "Ninja", "Pirate", "Spaghetti"],

data/spec/core/query_spec.rb

@@ -334,4 +334,14 @@ describe "Arel-like syntax" do
       end
     end
   end
+
+  describe "apply_where" do
+    context "matches regexp with block input" do
+      subject { dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" } }
+
+      let(:dv) { Daru::Vector.new ['3 days', '5 weeks', '2 weeks'] }
+
+      it { is_expected.to eq(Daru::Vector.new ['3 days', '35 days', '14 days']) }
+    end
+  end
 end

data/spec/dataframe_spec.rb

@@ -738,6 +738,47 @@ describe Daru::DataFrame do
     }
   end
 
+  context "#insert_vector" do
+    subject(:data_frame) {
+      Daru::DataFrame.new({b: [11,12,13,14,15], a: [1,2,3,4,5],
+        c: [11,22,33,44,55]}, order: [:a, :b, :c],
+        index: [:one, :two, :three, :four, :five])
+    }
+
+    it "insert a new vector at the desired slot" do
+      df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        d: [710, 720, 730, 740, 750],
+        b: [11, 12, 13, 14, 15],
+        c: [11,22,33,44,55]}, order: [:a, :d, :b, :c],
+        index: [:one, :two, :three, :four, :five]
+      )
+      data_frame.insert_vector 1, :d, [710, 720, 730, 740, 750]
+      expect(subject).to eq df
+    end
+
+    it "raises error for data array being too big" do
+      expect {
+        source = (1..8).to_a
+        data_frame.insert_vector 1, :d, source
+      }.to raise_error(IndexError)
+    end
+
+    it "raises error for invalid index value" do
+      expect {
+        source = (1..5).to_a
+        data_frame.insert_vector 4, :d, source
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises error for invalid source type" do
+      expect {
+        source = 14
+        data_frame.insert_vector 3, :d, source
+      }.to raise_error(ArgumentError)
+    end
+  end
+
   context "#row[]=" do
     context Daru::Index do
       before :each do
@@ -2720,6 +2761,26 @@ describe Daru::DataFrame do
     end
   end
 
+  context "#rename_vectors!" do
+    before do
+      @df = Daru::DataFrame.new({
+        a: [1,2,3,4,5],
+        b: [11,22,33,44,55],
+        c: %w(a b c d e)
+      })
+    end
+
+    it "returns self as modified dataframe" do
+      expect(@df.rename_vectors!(:a => :alpha)).to eq(@df)
+    end
+
+    it "re-uses rename_vectors method" do
+      name_map = { :a => :alpha, :c => :gamma }
+      expect(@df).to receive(:rename_vectors).with(name_map)
+      @df.rename_vectors! name_map
+    end
+  end
+
   context "#rename_vectors" do
     before do
       @df = Daru::DataFrame.new({
@@ -2729,6 +2790,10 @@ describe Daru::DataFrame do
       })
     end
 
+    it "returns Daru::Index" do
+      expect(@df.rename_vectors(:a => :alpha)).to be_kind_of(Daru::Index)
+    end
+
     it "renames vectors using a hash map" do
       @df.rename_vectors :a => :alpha, :c => :gamma
       expect(@df.vectors.to_a).to eq([:alpha, :b, :gamma])
@@ -3972,6 +4037,21 @@ describe Daru::DataFrame do
         |  12   1   1   1
         |  13   1   1   1
         |  14   1   1   1
+        |  15   1   1   1
+        |  16   1   1   1
+        |  17   1   1   1
+        |  18   1   1   1
+        |  19   1   1   1
+        |  20   1   1   1
+        |  21   1   1   1
+        |  22   1   1   1
+        |  23   1   1   1
+        |  24   1   1   1
+        |  25   1   1   1
+        |  26   1   1   1
+        |  27   1   1   1
+        |  28   1   1   1
+        |  29   1   1   1
         | ... ... ... ...
        }.unindent}
     end

data/spec/date_time/date_time_index_helper_spec.rb

@@ -0,0 +1,72 @@
+include Daru
+
+describe Daru::DateTimeIndexHelper do
+
+
+  describe '.infer_offset' do
+    subject(:offset) { Daru::DateTimeIndexHelper.infer_offset(data) }
+
+    context 'when the dataset does not have a regular offset' do
+      let(:data) do
+        [
+          DateTime.new(2020, 1, 1, 00, 00, 00),
+          DateTime.new(2020, 1, 1, 00, 01, 00),
+          DateTime.new(2020, 1, 1, 00, 05, 00),
+        ]
+      end
+
+      it 'returns nil' do
+        expect(offset).to be_nil
+      end
+    end
+
+    context 'when the dataset matches a defined offset' do
+      let(:data) do
+        [
+          DateTime.new(2020, 1, 1, 00, 00, 00),
+          DateTime.new(2020, 1, 1, 00, 01, 00),
+          DateTime.new(2020, 1, 1, 00, 02, 00),
+        ]
+      end
+
+      it 'returns the matched offset' do
+        expect(offset).to be_an_instance_of(Daru::Offsets::Minute)
+      end
+    end
+
+    context 'when the offset is a multiple of seconds' do
+      let(:data) do
+        [
+          DateTime.new(2020, 1, 1, 00, 00, 00),
+          DateTime.new(2020, 1, 1, 00, 00, 03),
+          DateTime.new(2020, 1, 1, 00, 00, 06),
+        ]
+      end
+
+      let(:expected_offset) { Daru::Offsets::Second.new(3) }
+
+      it 'returns a Second offset' do
+        expect(offset).to be_an_instance_of(Daru::Offsets::Second)
+      end
+
+      it 'has the correct multiplier' do
+        expect(offset.freq_string).to eql(expected_offset.freq_string)
+      end
+    end
+
+    context 'when the offset is less than a second' do
+      let(:data) do
+        [
+          DateTime.new(2020, 1, 1, 00, 00, 00) + 0.00001,
+          DateTime.new(2020, 1, 1, 00, 00, 00) + 0.00002,
+          DateTime.new(2020, 1, 1, 00, 00, 00) + 0.00003,
+        ]
+      end
+
+      it 'returns nil' do
+        expect(offset).to be_nil
+      end
+    end
+  end
+
+end