daru_lite 0.1.1 → 0.1.2

data/lib/daru_lite/index/index.rb

@@ -246,6 +246,19 @@ module DaruLite
       DaruLite::Index.new(to_a + indexes)
     end
 
+    # Takes a positional value and returns a new Index without the element at given position
+    # @param position [Integer] positional value
+    # @return [object] index object
+    # @example
+    #   idx = DaruLite::Index.new [:a, :b, :c]
+    #   idx.delete_at(0)
+    #   # => #<DaruLite::Index(2): {b, c}>
+    def delete_at(position)
+      indexes = to_a
+      indexes.delete_at(position)
+      self.class.new(indexes)
+    end
+
     def _dump(*)
       Marshal.dump(relation_hash: @relation_hash)
     end

data/lib/daru_lite/maths/statistics/vector.rb

@@ -842,7 +842,7 @@ module DaruLite
         def emsd(n = 10, wilder = false)
           result = []
           emv_return = emv(n, wilder)
-          emv_return.each do |d|
+          emv_return.each do |d| # rubocop:disable Style/MapIntoArray
             result << (d.nil? ? nil : Math.sqrt(d))
           end
           DaruLite::Vector.new(result, index: @index, name: @name)

data/lib/daru_lite/vector/aggregatable.rb

@@ -0,0 +1,9 @@
+module DaruLite
+  class Vector
+    module Aggregatable
+      def group_by(*args)
+        to_df.group_by(*args)
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/calculatable.rb

@@ -0,0 +1,78 @@
+module DaruLite
+  class Vector
+    module Calculatable
+      # Count the number of values specified
+      # @param values [Array] values to count for
+      # @return [Integer] the number of times the values mentioned occurs
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, 1, 2, 3, 4, nil, nil]
+      #   dv.count_values nil
+      #   # => 2
+      def count_values(*values)
+        positions(*values).size
+      end
+
+      # Create a summary of the Vector
+      # @param indent_level [Fixnum] indent level
+      # @return [String] String containing the summary of the Vector
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, 3]
+      #   puts dv.summary
+      #
+      #   # =
+      #   #   n :3
+      #   #   non-missing:3
+      #   #   median: 2
+      #   #   mean: 2.0000
+      #   #   std.dev.: 1.0000
+      #   #   std.err.: 0.5774
+      #   #   skew: 0.0000
+      #   #   kurtosis: -2.3333
+      def summary(indent_level = 0)
+        non_missing = size - count_values(*DaruLite::MISSING_VALUES)
+        summary = ('  =' * indent_level) + "= #{name}" \
+                                           "\n  n :#{size}" \
+                                           "\n  non-missing:#{non_missing}"
+        case type
+        when :object
+          summary << object_summary
+        when :numeric
+          summary << numeric_summary
+        end
+        summary.split("\n").join("\n#{'  ' * indent_level}")
+      end
+
+      # Displays summary for an object type Vector
+      # @return [String] String containing object vector summary
+      def object_summary
+        nval = count_values(*DaruLite::MISSING_VALUES)
+        summary = "\n  factors: #{factors.to_a.join(',')}" \
+                  "\n  mode: #{mode.to_a.join(',')}" \
+                  "\n  Distribution\n"
+
+        data = frequencies.sort.each_with_index.map do |v, k|
+          [k, v, format('%0.2f%%', ((nval.zero? ? 1 : v.quo(nval)) * 100))]
+        end
+
+        summary + Formatters::Table.format(data)
+      end
+
+      # Displays summary for an numeric type Vector
+      # @return [String] String containing numeric vector summary
+      def numeric_summary
+        summary = "\n  median: #{median}" +
+                  format("\n  mean: %0.4f", mean)
+        if sd
+          summary << (format("\n  std.dev.: %0.4f", sd) +
+                    format("\n  std.err.: %0.4f", se))
+        end
+
+        if count_values(*DaruLite::MISSING_VALUES).zero?
+          summary << (format("\n  skew: %0.4f", skew) +
+                    format("\n  kurtosis: %0.4f", kurtosis))
+        end
+        summary
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/convertible.rb

@@ -0,0 +1,77 @@
+module DaruLite
+  class Vector
+    module Convertible
+      # @return [DaruLite::DataFrame] the vector as a single-vector dataframe
+      def to_df
+        DaruLite::DataFrame.new({ @name => @data }, name: @name, index: @index)
+      end
+
+      # Convert Vector to a horizontal or vertical Ruby Matrix.
+      #
+      # == Arguments
+      #
+      # * +axis+ - Specify whether you want a *:horizontal* or a *:vertical* matrix.
+      def to_matrix(axis = :horizontal)
+        case axis
+        when :horizontal
+          Matrix[to_a]
+        when :vertical
+          Matrix.columns([to_a])
+        else
+          raise ArgumentError, "axis should be either :horizontal or :vertical, not #{axis}"
+        end
+      end
+
+      # Convert to hash (explicit). Hash keys are indexes and values are the correspoding elements
+      def to_h
+        @index.to_h { |index| [index, self[index]] }
+      end
+
+      # Return an array
+      def to_a
+        @data.to_a
+      end
+
+      # Convert the hash from to_h to json
+      def to_json(*)
+        to_h.to_json
+      end
+
+      # Convert to html for iruby
+      def to_html(threshold = 30)
+        table_thead = to_html_thead
+        table_tbody = to_html_tbody(threshold)
+        path = if index.is_a?(MultiIndex)
+                 File.expand_path('../iruby/templates/vector_mi.html.erb', __dir__)
+               else
+                 File.expand_path('../iruby/templates/vector.html.erb', __dir__)
+               end
+        ERB.new(File.read(path).strip).result(binding)
+      end
+
+      def to_html_thead
+        table_thead_path =
+          if index.is_a?(MultiIndex)
+            File.expand_path('../iruby/templates/vector_mi_thead.html.erb', __dir__)
+          else
+            File.expand_path('../iruby/templates/vector_thead.html.erb', __dir__)
+          end
+        ERB.new(File.read(table_thead_path).strip).result(binding)
+      end
+
+      def to_html_tbody(threshold = 30)
+        table_tbody_path =
+          if index.is_a?(MultiIndex)
+            File.expand_path('../iruby/templates/vector_mi_tbody.html.erb', __dir__)
+          else
+            File.expand_path('../iruby/templates/vector_tbody.html.erb', __dir__)
+          end
+        ERB.new(File.read(table_tbody_path).strip).result(binding)
+      end
+
+      def to_s
+        "#<#{self.class}#{": #{@name}" if @name}(#{size})#{':category' if category?}>"
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/duplicatable.rb

@@ -0,0 +1,17 @@
+module DaruLite
+  class Vector
+    module Duplicatable
+      # Duplicated a vector
+      # @return [DaruLite::Vector] duplicated vector
+      def dup
+        DaruLite::Vector.new @data.dup, name: @name, index: @index.dup
+      end
+
+      # Copies the structure of the vector (i.e the index, size, etc.) and fills all
+      # all values with nils.
+      def clone_structure
+        DaruLite::Vector.new(([nil] * size), name: @name, index: @index.dup)
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/fetchable.rb

@@ -0,0 +1,175 @@
+module DaruLite
+  class Vector
+    module Fetchable
+      # Get one or more elements with specified index or a range.
+      #
+      # == Usage
+      #   # For vectors employing single layer Index
+      #
+      #   v[:one, :two] # => DaruLite::Vector with indexes :one and :two
+      #   v[:one]       # => Single element
+      #   v[:one..:three] # => DaruLite::Vector with indexes :one, :two and :three
+      #
+      #   # For vectors employing hierarchial multi index
+      #
+      def [](*input_indexes)
+        # Get array of positions indexes
+        positions = @index.pos(*input_indexes)
+
+        # If one object is asked return it
+        return @data[positions] if positions.is_a? Numeric
+
+        # Form a new Vector using positional indexes
+        DaruLite::Vector.new(
+          positions.map { |loc| @data[loc] },
+          name: @name,
+          index: @index.subset(*input_indexes), dtype: @dtype
+        )
+      end
+
+      # Returns vector of values given positional values
+      # @param positions [Array<object>] positional values
+      # @return [object] vector
+      # @example
+      #   dv = DaruLite::Vector.new 'a'..'e'
+      #   dv.at 0, 1, 2
+      #   # => #<DaruLite::Vector(3)>
+      #   #   0   a
+      #   #   1   b
+      #   #   2   c
+      def at(*positions)
+        # to be used to form index
+        original_positions = positions
+        positions = coerce_positions(*positions)
+        validate_positions(*positions)
+
+        if positions.is_a? Integer
+          @data[positions]
+        else
+          values = positions.map { |pos| @data[pos] }
+          DaruLite::Vector.new values, index: @index.at(*original_positions), dtype: dtype
+        end
+      end
+
+      def head(q = 10)
+        self[0..(q - 1)]
+      end
+
+      def tail(q = 10)
+        start = [size - q, 0].max
+        self[start..(size - 1)]
+      end
+
+      def last(q = 1)
+        # The Enumerable mixin dose not provide the last method.
+        tail(q)
+      end
+
+      # Returns a hash of Vectors, defined by the different values
+      # defined on the fields
+      # Example:
+      #
+      #  a=DaruLite::Vector.new(["a,b","c,d","a,b"])
+      #  a.split_by_separator
+      #  =>  {"a"=>#<DaruLite::Vector:0x7f2dbcc09d88
+      #        @data=[1, 0, 1]>,
+      #       "b"=>#<DaruLite::Vector:0x7f2dbcc09c48
+      #        @data=[1, 1, 0]>,
+      #      "c"=>#<DaruLite::Vector:0x7f2dbcc09b08
+      #        @data=[0, 1, 1]>}
+      #
+      def split_by_separator(sep = ',')
+        split_data = splitted sep
+        split_data
+          .flatten.uniq.compact.to_h do |key|
+          [
+            key,
+            DaruLite::Vector.new(split_data.map { |v| split_value(key, v) })
+          ]
+        end
+      end
+
+      def split_by_separator_freq(sep = ',')
+        split_by_separator(sep).transform_values do |v|
+          v.sum(&:to_i)
+        end
+      end
+
+      # @param keys [Array] can be positions (if by_position is true) or indexes (if by_position if false)
+      # @return [DaruLite::Vector]
+      def get_sub_vector(keys, by_position: true)
+        return DaruLite::Vector.new([]) if keys == []
+
+        keys = @index.pos(*keys) unless by_position
+
+        sub_vect = at(*keys)
+        sub_vect = DaruLite::Vector.new([sub_vect]) unless sub_vect.is_a?(DaruLite::Vector)
+
+        sub_vect
+      end
+
+      # Partition a numeric variable into categories.
+      # @param [Array<Numeric>] partitions an array whose consecutive elements
+      #   provide intervals for categories
+      # @param [Hash] opts options to cut the partition
+      # @option opts [:left, :right] :close_at specifies whether the interval closes at
+      #   the right side of left side
+      # @option opts [Array] :labels names of the categories
+      # @return [DaruLite::Vector] numeric variable converted to categorical variable
+      # @example
+      #   heights = DaruLite::Vector.new [30, 35, 32, 50, 42, 51]
+      #   height_cat = heights.cut [30, 40, 50, 60], labels=['low', 'medium', 'high']
+      #   # => #<DaruLite::Vector(6)>
+      #   #       0    low
+      #   #       1    low
+      #   #       2    low
+      #   #       3   high
+      #   #       4 medium
+      #   #       5   high
+      def cut(partitions, opts = {})
+        close_at = opts[:close_at] || :right
+        labels = opts[:labels]
+        partitions = partitions.to_a
+        values = to_a.map { |val| cut_find_category partitions, val, close_at }
+        cats = cut_categories(partitions, close_at)
+
+        dv = DaruLite::Vector.new values,
+                                  index: @index,
+                                  type: :category,
+                                  categories: cats
+
+        # Rename categories if new labels provided
+        if labels
+          dv.rename_categories cats.zip(labels).to_h
+        else
+          dv
+        end
+      end
+
+      def positions(*values)
+        case values
+        when [nil]
+          nil_positions
+        when [Float::NAN]
+          nan_positions
+        when [nil, Float::NAN], [Float::NAN, nil]
+          nil_positions + nan_positions
+        else
+          size.times.select { |i| include_with_nan? values, @data[i] }
+        end
+      end
+
+      private
+
+      def split_value(key, v)
+        if v.nil?
+          nil
+        elsif v.include?(key)
+          1
+        else
+          0
+        end
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/filterable.rb

@@ -0,0 +1,128 @@
+module DaruLite
+  class Vector
+    module Filterable
+      # Return a new vector based on the contents of a boolean array. Use with the
+      # comparator methods to obtain meaningful results. See this notebook for
+      # a good overview of using #where.
+      #
+      # @param bool_array [DaruLite::Core::Query::BoolArray, Array<TrueClass, FalseClass>] The
+      #   collection containing the true of false values. Each element in the Vector
+      #   corresponding to a `true` in the bool_arry will be returned alongwith it's
+      #   index.
+      # @example Usage of #where.
+      #   vector = DaruLite::Vector.new([2,4,5,51,5,16,2,5,3,2,1,5,2,5,2,1,56,234,6,21])
+      #
+      #   # Simple logic statement passed to #where.
+      #   vector.where(vector.eq(5).or(vector.eq(1)))
+      #   # =>
+      #   ##<DaruLite::Vector:77626210 @name = nil @size = 7 >
+      #   #    nil
+      #   #  2   5
+      #   #  4   5
+      #   #  7   5
+      #   # 10   1
+      #   # 11   5
+      #   # 13   5
+      #   # 15   1
+      #
+      #   # A somewhat more complex logic statement
+      #   vector.where((vector.eq(5) | vector.lteq(1)) & vector.in([4,5,1]))
+      #   #=>
+      #   ##<DaruLite::Vector:81072310 @name = nil @size = 7 >
+      #   #    nil
+      #   #  2   5
+      #   #  4   5
+      #   #  7   5
+      #   # 10   1
+      #   # 11   5
+      #   # 13   5
+      #   # 15   1
+      def where(bool_array)
+        DaruLite::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 [DaruLite::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 [DaruLite::Vector]
+      #
+      # @example Usage of #apply_where.
+      #   dv = DaruLite::Vector.new ['3 days', '5 weeks', '2 weeks']
+      #   dv = dv.apply_where(dv.match /weeks/) { |x| "#{x.split.first.to_i * 7} days" }
+      #   # =>
+      #   ##<DaruLite::Vector(3)>
+      #   #  0   3 days
+      #   #  1   35 days
+      #   #  2   14 days
+      def apply_where(bool_array, &block)
+        DaruLite::Core::Query.vector_apply_where self, bool_array, &block
+      end
+
+      # Keep only unique elements of the vector alongwith their indexes.
+      def uniq
+        uniq_vector = @data.uniq
+        new_index   = uniq_vector.map { |element| index_of(element) }
+
+        DaruLite::Vector.new uniq_vector, name: @name, index: new_index, dtype: @dtype
+      end
+
+      # Delete an element if block returns true. Destructive.
+      def delete_if
+        return to_enum(:delete_if) unless block_given?
+
+        keep_e, keep_i = each_with_index.reject { |n, _i| yield(n) }.transpose
+
+        @data = cast_vector_to @dtype, keep_e
+        @index = DaruLite::Index.new(keep_i)
+
+        update_position_cache
+
+        self
+      end
+
+      # Keep an element if block returns true. Destructive.
+      def keep_if
+        return to_enum(:keep_if) unless block_given?
+
+        delete_if { |val| !yield(val) }
+      end
+
+      # Return a vector with specified values removed
+      # @param values [Array] values to reject from resultant vector
+      # @return [DaruLite::Vector] vector with specified values removed
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, nil, Float::NAN]
+      #   dv.reject_values nil, Float::NAN
+      #   # => #<DaruLite::Vector(2)>
+      #   #   0   1
+      #   #   1   2
+      def reject_values(*values)
+        resultant_pos = size.times.to_a - positions(*values)
+        dv = at(*resultant_pos)
+        # Handle the case when number of positions is 1
+        # and hence #at doesn't return a vector
+        if dv.is_a?(DaruLite::Vector)
+          dv
+        else
+          pos = resultant_pos.first
+          at(pos..pos)
+        end
+      end
+
+      # Returns a Vector with only numerical data. Missing data is included
+      # but non-Numeric objects are excluded. Preserves index.
+      def only_numerics
+        numeric_indexes =
+          each_with_index
+          .select { |v, _i| v.is_a?(Numeric) || v.nil? }
+          .map(&:last)
+
+        self[*numeric_indexes]
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/indexable.rb

@@ -0,0 +1,77 @@
+module DaruLite
+  class Vector
+    module Indexable
+      # Get index of element
+      def index_of(element)
+        case dtype
+        when :array then @index.key(@data.index { |x| x.eql? element })
+        else @index.key @data.index(element)
+        end
+      end
+
+      def reset_index!
+        @index = DaruLite::Index.new(Array.new(size) { |i| i })
+        self
+      end
+
+      # Returns *true* if an index exists
+      def has_index?(index) # rubocop:disable Naming/PredicateName
+        @index.include? index
+      end
+
+      def detach_index
+        DaruLite::DataFrame.new(
+          index: @index.to_a,
+          values: @data.to_a
+        )
+      end
+
+      # Sets new index for vector. Preserves index->value correspondence.
+      # Sets nil for new index keys absent from original index.
+      # @note Unlike #reorder! which takes positions as input it takes
+      #   index as an input to reorder the vector
+      # @param [DaruLite::Index, DaruLite::MultiIndex] new_index new index to order with
+      # @return [DaruLite::Vector] vector reindexed with new index
+      def reindex!(new_index)
+        values = []
+        each_with_index do |val, i|
+          values[new_index[i]] = val if new_index.include?(i)
+        end
+        values.fill(nil, values.size, new_index.size - values.size)
+
+        @data = cast_vector_to @dtype, values
+        @index = new_index
+
+        update_position_cache
+
+        self
+      end
+
+      # Create a new vector with a different index, and preserve the indexing of
+      # current elements.
+      def reindex(new_index)
+        dup.reindex!(new_index)
+      end
+
+      def index=(idx)
+        idx = Index.coerce(idx)
+
+        raise ArgumentError, "Size of supplied index #{idx.size} does not match size of Vector" if idx.size != size
+        raise ArgumentError, 'Can only assign type Index and its subclasses.' unless idx.is_a?(DaruLite::Index)
+
+        @index = idx
+      end
+
+      # Return indexes of values specified
+      # @param values [Array] values to find indexes for
+      # @return [Array] array of indexes of values specified
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, nil, Float::NAN], index: 11..14
+      #   dv.indexes nil, Float::NAN
+      #   # => [13, 14]
+      def indexes(*values)
+        index.to_a.values_at(*positions(*values))
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/iterable.rb

@@ -0,0 +1,95 @@
+module DaruLite
+  class Vector
+    module Iterable
+      def each(&block)
+        return to_enum(:each) unless block
+
+        @data.each(&block)
+        self
+      end
+
+      def each_index(&block)
+        return to_enum(:each_index) unless block
+
+        @index.each(&block)
+        self
+      end
+
+      def each_with_index(&block)
+        return to_enum(:each_with_index) unless block
+
+        @data.to_a.zip(@index.to_a).each(&block)
+
+        self
+      end
+
+      def map!(&block)
+        return to_enum(:map!) unless block
+
+        @data.map!(&block)
+        self
+      end
+
+      # Like map, but returns a DaruLite::Vector with the returned values.
+      def recode(dt = nil, &block)
+        return to_enum(:recode, dt) unless block
+
+        dup.recode! dt, &block
+      end
+
+      # Destructive version of recode!
+      def recode!(dt = nil, &block)
+        return to_enum(:recode!, dt) unless block
+
+        @data.map!(&block).data
+        @data = cast_vector_to(dt || @dtype)
+        self
+      end
+
+      # Reports all values that doesn't comply with a condition.
+      # Returns a hash with the index of data and the invalid data.
+      def verify
+        (0...size)
+          .map { |i| [i, @data[i]] }
+          .reject { |_i, val| yield(val) }
+          .to_h
+      end
+
+      def apply_method(method, keys: nil, by_position: true)
+        vect = keys ? get_sub_vector(keys, by_position: by_position) : self
+
+        case method
+        when Symbol then vect.send(method)
+        when Proc   then method.call(vect)
+        else raise
+        end
+      end
+      alias apply_method_on_sub_vector apply_method
+
+      # Replaces specified values with a new value
+      # @param [Array] old_values array of values to replace
+      # @param [object] new_value new value to replace with
+      # @note It performs the replace in place.
+      # @return [DaruLite::Vector] Same vector itself with values
+      #   replaced with new value
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, :a, :b]
+      #   dv.replace_values [:a, :b], nil
+      #   dv
+      #   # =>
+      #   # #<DaruLite::Vector:19903200 @name = nil @metadata = {} @size = 4 >
+      #   #     nil
+      #   #   0   1
+      #   #   1   2
+      #   #   2 nil
+      #   #   3 nil
+      def replace_values(old_values, new_value)
+        old_values = [old_values] unless old_values.is_a? Array
+        size.times do |pos|
+          set_at([pos], new_value) if include_with_nan? old_values, at(pos)
+        end
+        self
+      end
+    end
+  end
+end