daru 0.1.5 → 0.3

data/lib/daru/date_time/index.rb

@@ -93,11 +93,12 @@ module Daru
       def infer_offset data
         diffs = data.each_cons(2).map { |d1, d2| d2 - d1 }
 
-        if diffs.uniq.count == 1
-          TIME_INTERVALS[diffs.first].new
-        else
-          nil
-        end
+        return nil unless diffs.uniq.count == 1
+
+        return TIME_INTERVALS[diffs.first].new if TIME_INTERVALS.include?(diffs.first)
+
+        number_of_seconds = diffs.first / Daru::Offsets::Second.new.multiplier
+        Daru::Offsets::Second.new(number_of_seconds.numerator) if number_of_seconds.denominator == 1
       end
 
       def find_index_of_date data, date_time
@@ -226,7 +227,7 @@ module Daru
       to_a.each(&block)
     end
 
-    attr_reader :frequency, :offset, :periods
+    attr_reader :frequency, :offset, :periods, :keys
 
     # Create a DateTimeIndex with or without a frequency in data. The constructor
     # should be used for creating DateTimeIndex by directly passing in DateTime
@@ -253,6 +254,7 @@ module Daru
     #     DateTime.new(2012,4,11), DateTime.new(2012,4,12)], freq: :infer)
     #   #=>#<DateTimeIndex:84198340 offset=D periods=8 data=[2012-04-05T00:00:00+00:00...2012-04-12T00:00:00+00:00]>
     def initialize data, opts={freq: nil}
+      super data
       Helper.possibly_convert_to_date_time data
 
       @offset =
@@ -343,7 +345,7 @@ module Daru
 
     # Retreive a slice or a an individual index number from the index.
     #
-    # @param [String, DateTime] Specify a date partially (as a String) or
+    # @param key [String, DateTime] Specify a date partially (as a String) or
     #   completely to retrieve.
     def [] *key
       return slice(*key) if key.size != 1
@@ -405,7 +407,7 @@ module Daru
         @data
       else
         @data.sort_by(&:last)
-      end.transpose.first
+      end.transpose.first || []
     end
 
     # Size of index.
@@ -419,6 +421,7 @@ module Daru
 
     def inspect
       meta = [@periods, @frequency ? "frequency=#{@frequency}" : nil].compact.join(', ')
+      return "#<#{self.class}(#{meta})>" if @data.empty?
       "#<#{self.class}(#{meta}) " \
          "#{@data.first[0]}...#{@data.last[0]}>"
     end
@@ -490,7 +493,7 @@ module Daru
     #   @return [Array<Integer>] Array containing minutes of each index.
     # @!method sec
     #   @return [Array<Integer>] Array containing seconds of each index.
-    [:year, :month, :day, :hour, :min, :sec].each do |meth|
+    %i[year month day hour min sec].each do |meth|
       define_method(meth) do
         each_with_object([]) do |d, arr|
           arr << d.send(meth)
@@ -528,7 +531,7 @@ module Daru
       slice first, last
     end
 
-    def slice_between_dates first, last # rubocop:disable Metrics/AbcSize
+    def slice_between_dates first, last # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity
       # about that ^ disable: I'm waiting for cleaner understanding
       # of offsets logic. Reference: https://github.com/v0dro/daru/commit/7e1c34aec9516a9ba33037b4a1daaaaf1de0726a#diff-a95ef410a8e1f4ea3cc48d231bb880faR250
       start    = @data.bsearch { |d| d[0] >= first }
@@ -542,7 +545,7 @@ module Daru
         st = @data.index(start)
         en = after_en ? @data.index(after_en) - 1 : Helper.last_date(@data)[1]
         return start[1] if st == en
-        DateTimeIndex.new(@data[st..en].transpose[0])
+        DateTimeIndex.new(@data[st..en].transpose[0] || []) # empty slice guard
       end
     end
 

data/lib/daru/date_time/offsets.rb

@@ -86,7 +86,7 @@ module Daru
 
   module Offsets
     class DateOffsetType < DateOffset
-      # @method initialize
+      # @!method initialize(n)
       # Initialize one of the subclasses of DateOffsetType with the number of the times
       # the offset should be applied, which is the supplied as the argument.
       #
@@ -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/extensions/which_dsl.rb

@@ -0,0 +1,55 @@
+# Support for a simple query DSL for accessing where(), inspired by gem "squeel"
+
+module Daru
+  class DataFrame
+    # a simple query DSL for accessing where(), inspired by gem "squeel"
+    # e.g.:
+    # df.which{ `FamilySize` == `FamilySize`.max }
+    # equals
+    # df.where( df['FamilySize'].eq( df['FamilySize'].max ) )
+    #
+    # e.g.:
+    # df.which{ (`NameTitle` == 'Dr') & (`Sex` == 'female') }
+    # equals
+    # df.where( df['NameTitle'].eq('Dr') & df['Sex'].eq('female') )
+    def which(&block)
+      WhichQuery.new(self, &block).exec
+    end
+  end
+
+  class WhichQuery
+    def initialize(df, &condition)
+      @df = df
+      @condition = condition
+    end
+
+    # executes a block of DSL code
+    def exec
+      query = instance_eval(&@condition)
+      @df.where(query)
+    end
+
+    def `(vector_name)
+      if !@df.has_vector?(vector_name) && @df.has_vector?(vector_name.to_sym)
+        vector_name = vector_name.to_sym
+      end
+      VectorWrapper.new(@df[vector_name])
+    end
+
+    class VectorWrapper < SimpleDelegator
+      {
+        :== => :eq,
+        :!= => :not_eq,
+        :<  => :lt,
+        :<= => :lteq,
+        :>  => :mt,
+        :>= => :mteq,
+        :=~ => :in
+      }.each do |opt, method|
+        define_method opt do |*args|
+          send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/daru/formatters/table.rb

@@ -10,15 +10,13 @@ module Daru
         @data = data || []
         @headers = (headers || []).to_a
         @row_headers = (row_headers || []).to_a
+        @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/index/categorical_index.rb

@@ -45,7 +45,7 @@ module Daru
     # Returns positions given categories or positions
     # @note If the argument does not a valid category it treats it as position
     #   value and return it as it is.
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @example
     #   x = Daru::CategoricalIndex.new [:a, 1, :a, 1, :c]
     #   x.pos :a, 1
@@ -145,7 +145,7 @@ module Daru
     end
 
     # Return subset given categories or positions
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @return [Daru::CategoricalIndex] subset of the self containing the
     #   mentioned categories or positions
     # @example
@@ -161,7 +161,7 @@ module Daru
 
     # Takes positional values and returns subset of the self
     #   capturing the categories at mentioned positions
-    # @param [Array<Integer>] positional values
+    # @param positions [Array<Integer>] positional values
     # @return [object] index object
     # @example
     #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
@@ -178,7 +178,7 @@ module Daru
     end
 
     # Add specified index values to the index object
-    # @param [Array<object>] *indexes index values to add
+    # @param indexes [Array<object>] index values to add
     # @return [Daru::CategoricalIndex] index object with added values
     # @example
     #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]

data/lib/daru/index/index.rb

@@ -1,5 +1,5 @@
 module Daru
-  class Index
+  class Index # rubocop:disable Metrics/ClassLength
     include Enumerable
     # It so happens that over riding the .new method in a super class also
     # tampers with the default .new method for class that inherit from the
@@ -44,30 +44,37 @@ module Daru
     end
 
     attr_reader :relation_hash, :size
+    attr_accessor :name
 
-    def initialize index
-      index =
-        case index
-        when nil
-          []
-        when Integer
-          index.times.to_a
-        when Enumerable
-          index.to_a
-        else
-          raise ArgumentError,
-            "Cannot create index from #{index.class} #{index.inspect}"
-        end
-
+    # @example
+    #
+    #   idx = Daru::Index.new [:one, 'one', 1, 2, :two]
+    #   => #<Daru::Index(5): {one, one, 1, 2, two}>
+    #
+    #   # set the name
+    #
+    #   idx.name = "index_name"
+    #   => "index_name"
+    #
+    #   idx
+    #   => #<Daru::Index(5): index_name {one, one, 1, 2, two}>
+    #
+    #   # set the name during initialization
+    #
+    #   idx = Daru::Index.new [:one, 'one', 1, 2, :two], name: "index_name"
+    #   => #<Daru::Index(5): index_name {one, one, 1, 2, two}>
+    def initialize index, opts={}
+      index = guess_index index
       @relation_hash = index.each_with_index.to_h.freeze
       @keys = @relation_hash.keys
       @size = @relation_hash.size
+      @name = opts[:name]
     end
 
     def ==(other)
       return false if self.class != other.class || other.size != @size
 
-      @relation_hash.keys == other.to_a &&
+      @keys == other.to_a &&
         @relation_hash.values == other.relation_hash.values
     end
 
@@ -83,7 +90,7 @@ module Daru
     end
 
     # Returns true if all arguments are either a valid category or position
-    # @param [Array<object>] *indexes categories or positions
+    # @param indexes [Array<object>] categories or positions
     # @return [true, false]
     # @example
     #   idx.valid? :a, 2
@@ -97,7 +104,7 @@ module Daru
     # Returns positions given indexes or positions
     # @note If the arugent is both a valid index and a valid position,
     #   it will treated as valid index
-    # @param [Array<object>] *indexes indexes or positions
+    # @param indexes [Array<object>] indexes or positions
     # @example
     #   x = Daru::Index.new [:a, :b, :c]
     #   x.pos :a, 1
@@ -106,27 +113,30 @@ module Daru
       indexes = preprocess_range(indexes.first) if indexes.first.is_a? Range
 
       if indexes.size == 1
-        self[indexes.first]
+        numeric_pos indexes.first
       else
-        indexes.map { |index| by_single_key index }
+        indexes.map { |index| numeric_pos index }
       end
     end
 
     def subset *indexes
       if indexes.first.is_a? Range
-        slice indexes.first.begin, indexes.first.end
+        start = indexes.first.begin
+        en = indexes.first.end
+
+        subset_slice start, en
       elsif include? indexes.first
         # Assume 'indexes' contain indexes not positions
         Daru::Index.new indexes
       else
         # Assume 'indexes' contain positions not indexes
-        Daru::Index.new indexes.map { |k| key k }
+        Daru::Index.new(indexes.map { |k| key k })
       end
     end
 
     # Takes positional values and returns subset of the self
     #   capturing the indexes at mentioned positions
-    # @param [Array<Integer>] positional values
+    # @param positions [Array<Integer>] positional values
     # @return [object] index object
     # @example
     #   idx = Daru::Index.new [:a, :b, :c]
@@ -143,10 +153,11 @@ module Daru
     end
 
     def inspect threshold=20
+      name_part = @name ? "#{@name} " : ''
       if size <= threshold
-        "#<#{self.class}(#{size}): {#{to_a.join(', ')}}>"
+        "#<#{self.class}(#{size}): #{name_part}{#{to_a.join(', ')}}>"
       else
-        "#<#{self.class}(#{size}): {#{to_a.first(threshold).join(', ')} ... #{to_a.last}}>"
+        "#<#{self.class}(#{size}): #{name_part}{#{to_a.first(threshold).join(', ')} ... #{to_a.last}}>"
       end
     end
 
@@ -154,12 +165,27 @@ module Daru
       start = args[0]
       en = args[1]
 
+      start_idx = @relation_hash[start]
+      en_idx    = @relation_hash[en]
+
+      if start_idx.nil?
+        nil
+      elsif en_idx.nil?
+        Array(start_idx..size-1)
+      else
+        Array(start_idx..en_idx)
+      end
+    end
+
+    def subset_slice *args
+      start = args[0]
+      en = args[1]
+
       if start.is_a?(Integer) && en.is_a?(Integer)
         Index.new @keys[start..en]
       else
         start_idx = @relation_hash[start]
         en_idx    = @relation_hash[en]
-
         Index.new @keys[start_idx..en_idx]
       end
     end
@@ -175,7 +201,7 @@ module Daru
     end
 
     def to_a
-      @relation_hash.keys
+      @keys
     end
 
     def key(value)
@@ -187,12 +213,33 @@ module Daru
       @relation_hash.key? index
     end
 
+    # @note Do not use it to check for Float::NAN as
+    #   Float::NAN == Float::NAN is false
+    # Return vector of booleans with value at ith position is either
+    # true or false depending upon whether index value at position i is equal to
+    # any of the values passed in the argument or not
+    # @param indexes [Array] values to equate with
+    # @return [Daru::Vector] vector of boolean values
+    # @example
+    #   dv = Daru::Index.new [1, 2, 3, :one, 'one']
+    #   dv.is_values 1, 'one'
+    #   # => #<Daru::Vector(5)>
+    #   #     0  true
+    #   #     1  false
+    #   #     2  false
+    #   #     3  false
+    #   #     4  true
+    def is_values(*indexes) # rubocop:disable Style/PredicateName
+      bool_array = @keys.map { |r| indexes.include?(r) }
+      Daru::Vector.new(bool_array)
+    end
+
     def empty?
-      @relation_hash.empty?
+      @size.zero?
     end
 
     def dup
-      Daru::Index.new @relation_hash.keys
+      Daru::Index.new @keys, name: @name
     end
 
     def add *indexes
@@ -211,7 +258,7 @@ module Daru
 
     # Provide an Index for sub vector produced
     #
-    # @param input_indexes [Array] the input by user to index the vector
+    # @option * [Array] the input by user to index the vector
     # @return [Object] the Index object for sub vector produced
     def conform(*)
       self
@@ -222,8 +269,49 @@ module Daru
       self.class.new(new_order.map { |i| from[i] })
     end
 
+    # Sorts a `Index`, according to its values. Defaults to ascending order
+    # sorting.
+    #
+    # @param [Hash] opts the options for sort method.
+    # @option opts [Boolean] :ascending False, to get descending order.
+    #
+    # @return [Index] sorted `Index` according to its values.
+    #
+    # @example
+    #   di = Daru::Index.new [100, 99, 101, 1, 2]
+    #   # Say you want to sort in descending order
+    #   di.sort(ascending: false) #=> Daru::Index.new [101, 100, 99, 2, 1]
+    #   # Say you want to sort in ascending order
+    #   di.sort #=> Daru::Index.new [1, 2, 99, 100, 101]
+    def sort opts={}
+      opts = {ascending: true}.merge(opts)
+
+      new_index = @keys.sort
+      new_index = new_index.reverse unless opts[:ascending]
+
+      self.class.new(new_index)
+    end
+
+    def to_df
+      Daru::DataFrame.new(name => to_a)
+    end
+
     private
 
+    def guess_index index
+      case index
+      when nil
+        []
+      when Integer
+        index.times.to_a
+      when Enumerable
+        index.to_a
+      else
+        raise ArgumentError,
+          "Cannot create index from #{index.class} #{index.inspect}"
+      end
+    end
+
     def preprocess_range rng
       start   = rng.begin
       en      = rng.end
@@ -243,30 +331,21 @@ module Daru
     end
 
     def by_multi_key *key
-      if include? key[0]
-        Daru::Index.new key.map { |k| k }
-      else
-        # Assume the user is specifing values for index not keys
-        # Return index object having keys corresponding to values provided
-        Daru::Index.new key.map { |k| key k }
-      end
+      key.map { |k| by_single_key k }
     end
 
     def by_single_key key
       if @relation_hash.key?(key)
         @relation_hash[key]
-      elsif key.is_a?(Numeric) && key < size
-        key
       else
-        raise IndexError, "Specified index #{key.inspect} does not exist"
+        nil
       end
     end
 
     # Raises IndexError when one of the positions is an invalid position
     def validate_positions *positions
-      positions = [positions] if positions.is_a? Integer
       positions.each do |pos|
-        raise IndexError, "#{pos} is not a valid position." if pos >= size
+        raise IndexError, "#{pos} is not a valid position." if pos >= size || pos < -size
       end
     end
 
@@ -285,5 +364,15 @@ module Daru
         positions
       end
     end
+
+    def numeric_pos key
+      if @relation_hash.key?(key)
+        @relation_hash[key]
+      elsif key.is_a?(Numeric) && (key < size && key >= -size)
+        key
+      else
+        raise IndexError, "Specified index #{key.inspect} does not exist"
+      end
+    end
   end
 end