daru 0.1.4.1 → 0.1.5

data/lib/daru/date_time/index.rb

@@ -87,8 +87,7 @@ module Daru
       def verify_start_and_end start, en
         raise ArgumentError, 'Start and end cannot be the same' if start == en
         raise ArgumentError, 'Start must be lesser than end'    if start > en
-        raise ArgumentError,
-          'Only same time zones are allowed' if start.zone != en.zone
+        raise ArgumentError, 'Only same time zones are allowed' if start.zone != en.zone
       end
 
       def infer_offset data
@@ -285,7 +284,7 @@ module Daru
     # @option opts [String, Daru::DateOffset, Daru::Offsets::*] :freq ('D') The interval
     #   between each date in the index. This can either be a string specifying
     #   the frequency (i.e. one of the frequency aliases) or an offset object.
-    # @option opts [Fixnum] :periods The number of periods that should go into
+    # @option opts [Integer] :periods The number of periods that should go into
     #   this index. Takes precedence over `:end`.
     # @return [DateTimeIndex] DateTimeIndex object of the specified parameters.
     #
@@ -389,7 +388,7 @@ module Daru
     # @param [String, DateTime] first Start of the slice as a string or DateTime.
     # @param [String, DateTime] last End of the slice as a string or DateTime.
     def slice first, last
-      if first.is_a?(Fixnum) && last.is_a?(Fixnum)
+      if first.is_a?(Integer) && last.is_a?(Integer)
         DateTimeIndex.new(to_a[first..last], freq: @offset)
       else
         first = Helper.find_date_string_bounds(first)[0] if first.is_a?(String)
@@ -427,7 +426,7 @@ module Daru
     # Shift all dates in the index by a positive number in the future. The dates
     # are shifted by the same amount as that specified in the offset.
     #
-    # @param [Fixnum, Daru::DateOffset, Daru::Offsets::*] distance Distance by
+    # @param [Integer, Daru::DateOffset, Daru::Offsets::*] distance Distance by
     #   which each date should be shifted. Passing an offset object to #shift
     #   will offset each data point by the offset value. Passing a positive
     #   integer will offset each data point by the same offset that it was
@@ -445,7 +444,7 @@ module Daru
     #   index.shift(4)
     #   #=>#<DateTimeIndex:83979630 offset=YEAR periods=10 data=[2016-01-01T00:00:00+00:00...2025-01-01T00:00:00+00:00]>
     def shift distance
-      distance.is_a?(Fixnum) && distance < 0 and
+      distance.is_a?(Integer) && distance < 0 and
         raise IndexError, "Distance #{distance} cannot be negative"
 
       _shift(distance)
@@ -454,14 +453,14 @@ module Daru
     # Shift all dates in the index to the past. The dates are shifted by the same
     # amount as that specified in the offset.
     #
-    # @param [Fixnum, Daru::DateOffset, Daru::Offsets::*] distance Fixnum or
+    # @param [Integer, Daru::DateOffset, Daru::Offsets::*] distance Integer or
     #   Daru::DateOffset. Distance by which each date should be shifted. Passing
     #   an offset object to #lag will offset each data point by the offset value.
     #   Passing a positive integer will offset each data point by the same offset
     #   that it was created with.
     # @return [DateTimeIndex] A new lagged DateTimeIndex object.
     def lag distance
-      distance.is_a?(Fixnum) && distance < 0 and
+      distance.is_a?(Integer) && distance < 0 and
         raise IndexError, "Distance #{distance} cannot be negative"
 
       _shift(-distance)
@@ -480,17 +479,17 @@ module Daru
     # :nocov:
 
     # @!method year
-    #   @return [Array<Fixnum>] Array containing year of each index.
+    #   @return [Array<Integer>] Array containing year of each index.
     # @!method month
-    #   @return [Array<Fixnum>] Array containing month of each index.
+    #   @return [Array<Integer>] Array containing month of each index.
     # @!method day
-    #   @return [Array<Fixnum>] Array containing day of each index.
+    #   @return [Array<Integer>] Array containing day of each index.
     # @!method hour
-    #   @return [Array<Fixnum>] Array containing hour of each index.
+    #   @return [Array<Integer>] Array containing hour of each index.
     # @!method min
-    #   @return [Array<Fixnum>] Array containing minutes of each index.
+    #   @return [Array<Integer>] Array containing minutes of each index.
     # @!method sec
-    #   @return [Array<Fixnum>] Array containing seconds of each index.
+    #   @return [Array<Integer>] Array containing seconds of each index.
     [:year, :month, :day, :hour, :min, :sec].each do |meth|
       define_method(meth) do
         each_with_object([]) do |d, arr|
@@ -521,7 +520,7 @@ module Daru
     private
 
     def get_by_range first, last
-      return slice(first, last) if first.is_a?(Fixnum) && last.is_a?(Fixnum)
+      return slice(first, last) if first.is_a?(Integer) && last.is_a?(Integer)
 
       raise ArgumentError, "Keys #{first} and #{last} are out of bounds" if
         Helper.key_out_of_bounds?(first, @data) && Helper.key_out_of_bounds?(last, @data)
@@ -548,7 +547,7 @@ module Daru
     end
 
     def _shift distance
-      if distance.is_a?(Fixnum)
+      if distance.is_a?(Integer)
         raise IndexError, 'To lag non-freq date time index pass an offset.' unless @offset
 
         start = @data[0][0]

data/lib/daru/date_time/offsets.rb

@@ -78,10 +78,19 @@ module Daru
     def - date_time
       @offset + date_time
     end
+
+    def -@
+      @offset
+    end
   end
 
   module Offsets
     class DateOffsetType < DateOffset
+      # @method initialize
+      # 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.
+      #
+      # @param n [Integer] The number of times an offset should be applied.
       def initialize n=1
         @n = n
       end
@@ -95,12 +104,6 @@ module Daru
     # @abstract
     # @private
     class Tick < DateOffsetType
-      # @method initialize
-      # Initialize one of the subclasses of Tick with the number of the times
-      # the offset should be applied, which is the supplied as the argument.
-      #
-      # @param n [Integer] The number of times an offset should be applied.
-
       def + date_time
         date_time + @n*multiplier
       end
@@ -121,7 +124,7 @@ module Daru
       FREQ = 'S'.freeze
 
       def multiplier
-        1.1574074074074073e-05
+        1.to_r / 24 / 60 / 60
       end
     end
 
@@ -136,7 +139,7 @@ module Daru
       FREQ = 'M'.freeze
 
       def multiplier
-        0.0006944444444444445
+        1.to_r / 24 / 60
       end
     end
 
@@ -151,7 +154,7 @@ module Daru
       FREQ = 'H'.freeze
 
       def multiplier
-        0.041666666666666664
+        1.to_r / 24
       end
     end
 
@@ -166,7 +169,7 @@ module Daru
       FREQ = 'D'.freeze
 
       def multiplier
-        1.0
+        1
       end
     end
 
@@ -210,7 +213,7 @@ module Daru
 
     class Week < DateOffset
       def initialize *args
-        @n = !args[0].is_a?(Hash)? args[0] : 1
+        @n = args[0].is_a?(Hash) ? 1 : args[0]
         opts = args[-1]
         @weekday = opts[:weekday] || 0
       end

data/lib/daru/formatters/table.rb

@@ -39,11 +39,11 @@ module Daru
       end
 
       def construct_formatter rows, spacing
-        width = rows.flatten.map(&:size).max
+        width = rows.flatten.map(&:size).max || 0
         width = [3, width].max # not less than 'nil'
         width = [width, spacing].min # not more than max width
 
-        " %#{width}.#{width}s" * rows.first.size
+        " %#{width}.#{width}s" * rows.first.size if rows.first
       end
 
       def pretty_to_s(val)

data/lib/daru/index/categorical_index.rb

@@ -0,0 +1,201 @@
+module Daru
+  class CategoricalIndex < Index
+    # Create a categorical index object.
+    # @param indexes [Array<object>] array of indexes
+    # @return [Daru::CategoricalIndex] categorical index
+    # @example
+    #   Daru::CategoricalIndex.new [:a, 1, :a, 1, :c]
+    #   # => #<Daru::CategoricalIndex(5): {a, 1, a, 1, c}>
+    def initialize indexes
+      # Create a hash to map each category to positional indexes
+      categories = indexes.each_with_index.group_by(&:first)
+      @cat_hash = categories.map { |cat, group| [cat, group.map(&:last)] }.to_h
+
+      # Map each category to a unique integer for effective storage in @array
+      map_cat_int = categories.keys.each_with_index.to_h
+
+      # To link every instance to its category,
+      # it stores integer for every instance representing its category
+      @array = map_cat_int.values_at(*indexes)
+    end
+
+    # Duplicates the index object and return it
+    # @return [Daru::CategoricalIndex] duplicated index object
+    def dup
+      # Improve it by intializing index by hash
+      Daru::CategoricalIndex.new to_a
+    end
+
+    # Returns true index or category is valid
+    # @param index [object] the index value to look for
+    # @return [true, false] true if index is included, false otherwise
+    def include? index
+      @cat_hash.include? index
+    end
+
+    # Returns array of categories
+    # @example
+    #   x = Daru::CategoricalIndex.new [:a, 1, :a, 1, :c]
+    #   x.categories
+    #   # => [:a, 1, :c]
+    def categories
+      @cat_hash.keys
+    end
+
+    # 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
+    # @example
+    #   x = Daru::CategoricalIndex.new [:a, 1, :a, 1, :c]
+    #   x.pos :a, 1
+    #   # => [0, 1, 2, 3]
+    def pos *indexes
+      positions = indexes.map do |index|
+        if include? index
+          @cat_hash[index]
+        elsif index.is_a?(Numeric) && index < @array.size
+          index
+        else
+          raise IndexError, "#{index.inspect} is neither a valid category"\
+            ' nor a valid position'
+        end
+      end
+
+      positions.flatten!
+      positions.size == 1 ? positions.first : positions.sort
+    end
+
+    # Returns index value from position
+    # @param pos [Integer] the position to look for
+    # @return [object] category corresponding to position
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
+    #   idx.index_from_pos 1
+    #   # => :b
+    def index_from_pos pos
+      cat_from_int @array[pos]
+    end
+
+    # Returns enumerator enumerating all index values in the order they occur
+    # @return [Enumerator] all index values
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :a, :b]
+    #   idx.each.to_a
+    #   # => [:a, :a, :b]
+    def each
+      return enum_for(:each) unless block_given?
+      @array.each { |pos| yield cat_from_int pos }
+      self
+    end
+
+    # Compares two index object. Returns true if every instance of category
+    # occur at the same position
+    # @param [Daru::CateogricalIndex] other index object to be checked against
+    # @return [true, false] true if other is similar to self
+    # @example
+    #   a = Daru::CategoricalIndex.new [:a, :a, :b]
+    #   b = Daru::CategoricalIndex.new [:b, :a, :a]
+    #   a == b
+    #   # => false
+    def == other
+      self.class == other.class &&
+        size == other.size &&
+        to_h == other.to_h
+    end
+
+    # Returns all the index values
+    # @return [Array] all index values
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a]
+    #   idx.to_a
+    def to_a
+      each.to_a
+    end
+
+    # Returns hash table mapping category to positions at which they occur
+    # @return [Hash] hash table mapping category to array of positions
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a]
+    #   idx.to_h
+    #   # => {:a=>[0, 2], :b=>[1]}
+    def to_h
+      @cat_hash
+    end
+
+    # Returns size of the index object
+    # @return [Integer] total number of instances of all categories
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a]
+    #   idx.size
+    #   # => 3
+    def size
+      @array.size
+    end
+
+    # Returns true if index object is storing no category
+    # @return [true, false] true if index object is empty
+    # @example
+    #   i = Daru::CategoricalIndex.new []
+    #   # => #<Daru::CategoricalIndex(0): {}>
+    #   i.empty?
+    #   # => true
+    def empty?
+      @array.empty?
+    end
+
+    # Return subset given categories or positions
+    # @param [Array<object>] *indexes categories or positions
+    # @return [Daru::CategoricalIndex] subset of the self containing the
+    #   mentioned categories or positions
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
+    #   idx.subset :a, :b
+    #   # => #<Daru::CategoricalIndex(4): {a, b, a, b}>
+    def subset *indexes
+      positions = pos(*indexes)
+      new_index = positions.map { |pos| index_from_pos pos }
+
+      Daru::CategoricalIndex.new new_index.flatten
+    end
+
+    # Takes positional values and returns subset of the self
+    #   capturing the categories at mentioned positions
+    # @param [Array<Integer>] positional values
+    # @return [object] index object
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
+    #   idx.at 0, 1
+    #   # => #<Daru::CategoricalIndex(2): {a, b}>
+    def at *positions
+      positions = preprocess_positions(*positions)
+      validate_positions(*positions)
+      if positions.is_a? Integer
+        index_from_pos(positions)
+      else
+        Daru::CategoricalIndex.new positions.map(&method(:index_from_pos))
+      end
+    end
+
+    # Add specified index values to the index object
+    # @param [Array<object>] *indexes index values to add
+    # @return [Daru::CategoricalIndex] index object with added values
+    # @example
+    #   idx = Daru::CategoricalIndex.new [:a, :b, :a, :b, :c]
+    #   idx.add :d
+    #   # => #<Daru::CategoricalIndex(6): {a, b, a, b, c, d}>
+    def add *indexes
+      Daru::CategoricalIndex.new(to_a + indexes)
+    end
+
+    private
+
+    def int_from_cat cat
+      @cat_hash.keys.index cat
+    end
+
+    def cat_from_int cat
+      @cat_hash.keys[cat]
+    end
+  end
+end

data/lib/daru/index/index.rb

@@ -0,0 +1,289 @@
+module Daru
+  class Index
+    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
+    # super class (Index in this case). Thus we first alias the original
+    # new method (from Object) to __new__ when the Index class is evaluated,
+    # and then we use an inherited hook such that the old new method (from
+    # Object) is once again the default .new for the subclass.
+    # Refer http://blog.sidu.in/2007/12/rubys-new-as-factory.html
+    class << self
+      alias :__new__ :new
+
+      def inherited subclass
+        class << subclass
+          alias :new :__new__
+        end
+      end
+    end
+
+    # We over-ride the .new method so that any sort of Index can be generated
+    # from Daru::Index based on the types of arguments supplied.
+    def self.new *args, &block
+      # FIXME: I'm not sure this clever trick really deserves our attention.
+      # Most of common ruby libraries just avoid it in favor of usual
+      # factor method, like `Index.create`. When `Index.new(...).class != Index`
+      # it just leads to confusion and surprises. - zverok, 2016-05-18
+      source = args.first
+
+      MultiIndex.try_from_tuples(source) ||
+        DateTimeIndex.try_create(source) ||
+        allocate.tap { |i| i.send :initialize, *args, &block }
+    end
+
+    def self.coerce maybe_index
+      maybe_index.is_a?(Index) ? maybe_index : Daru::Index.new(maybe_index)
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      @relation_hash.each_key(&block)
+      self
+    end
+
+    attr_reader :relation_hash, :size
+
+    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
+
+      @relation_hash = index.each_with_index.to_h.freeze
+      @keys = @relation_hash.keys
+      @size = @relation_hash.size
+    end
+
+    def ==(other)
+      return false if self.class != other.class || other.size != @size
+
+      @relation_hash.keys == other.to_a &&
+        @relation_hash.values == other.relation_hash.values
+    end
+
+    def [](key, *rest)
+      case
+      when key.is_a?(Range)
+        by_range key
+      when !rest.empty?
+        by_multi_key key, *rest
+      else
+        by_single_key key
+      end
+    end
+
+    # Returns true if all arguments are either a valid category or position
+    # @param [Array<object>] *indexes categories or positions
+    # @return [true, false]
+    # @example
+    #   idx.valid? :a, 2
+    #   # => true
+    #   idx.valid? 3
+    #   # => false
+    def valid? *indexes
+      indexes.all? { |i| to_a.include?(i) || (i.is_a?(Numeric) && i < size) }
+    end
+
+    # 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
+    # @example
+    #   x = Daru::Index.new [:a, :b, :c]
+    #   x.pos :a, 1
+    #   # => [0, 1]
+    def pos *indexes
+      indexes = preprocess_range(indexes.first) if indexes.first.is_a? Range
+
+      if indexes.size == 1
+        self[indexes.first]
+      else
+        indexes.map { |index| by_single_key index }
+      end
+    end
+
+    def subset *indexes
+      if indexes.first.is_a? Range
+        slice indexes.first.begin, indexes.first.end
+      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 }
+      end
+    end
+
+    # Takes positional values and returns subset of the self
+    #   capturing the indexes at mentioned positions
+    # @param [Array<Integer>] positional values
+    # @return [object] index object
+    # @example
+    #   idx = Daru::Index.new [:a, :b, :c]
+    #   idx.at 0, 1
+    #   # => #<Daru::Index(2): {a, b}>
+    def at *positions
+      positions = preprocess_positions(*positions)
+      validate_positions(*positions)
+      if positions.is_a? Integer
+        key(positions)
+      else
+        self.class.new positions.map(&method(:key))
+      end
+    end
+
+    def inspect threshold=20
+      if size <= threshold
+        "#<#{self.class}(#{size}): {#{to_a.join(', ')}}>"
+      else
+        "#<#{self.class}(#{size}): {#{to_a.first(threshold).join(', ')} ... #{to_a.last}}>"
+      end
+    end
+
+    def 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
+
+    # Produce new index from the set union of two indexes.
+    def |(other)
+      Index.new(to_a | other.to_a)
+    end
+
+    # Produce a new index from the set intersection of two indexes
+    def & other
+      Index.new(to_a & other.to_a)
+    end
+
+    def to_a
+      @relation_hash.keys
+    end
+
+    def key(value)
+      return nil unless value.is_a?(Numeric)
+      @keys[value]
+    end
+
+    def include? index
+      @relation_hash.key? index
+    end
+
+    def empty?
+      @relation_hash.empty?
+    end
+
+    def dup
+      Daru::Index.new @relation_hash.keys
+    end
+
+    def add *indexes
+      Daru::Index.new(to_a + indexes)
+    end
+
+    def _dump(*)
+      Marshal.dump(relation_hash: @relation_hash)
+    end
+
+    def self._load data
+      h = Marshal.load data
+
+      Daru::Index.new(h[:relation_hash].keys)
+    end
+
+    # Provide an Index for sub vector produced
+    #
+    # @param input_indexes [Array] the input by user to index the vector
+    # @return [Object] the Index object for sub vector produced
+    def conform(*)
+      self
+    end
+
+    def reorder(new_order)
+      from = to_a
+      self.class.new(new_order.map { |i| from[i] })
+    end
+
+    private
+
+    def preprocess_range rng
+      start   = rng.begin
+      en      = rng.end
+
+      if start.is_a?(Integer) && en.is_a?(Integer)
+        @keys[start..en]
+      else
+        start_idx = @relation_hash[start]
+        en_idx    = @relation_hash[en]
+
+        @keys[start_idx..en_idx]
+      end
+    end
+
+    def by_range rng
+      slice rng.begin, rng.end
+    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
+    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"
+      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
+      end
+    end
+
+    # Preprocess ranges, integers and array in appropriate ways
+    def preprocess_positions *positions
+      if positions.size == 1
+        case positions.first
+        when Integer
+          positions.first
+        when Range
+          size.times.to_a[positions.first]
+        else
+          raise ArgumentError, 'Unkown position type.'
+        end
+      else
+        positions
+      end
+    end
+  end
+end