daru_lite 0.1.1 → 0.1.3

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

data/lib/daru_lite/vector/joinable.rb

@@ -0,0 +1,17 @@
+module DaruLite
+  class Vector
+    module Joinable
+      # Append an element to the vector by specifying the element and index
+      def concat(element, index)
+        raise IndexError, 'Expected new unique index' if @index.include? index
+
+        @index |= [index]
+        @data[@index[index]] = element
+
+        update_position_cache
+      end
+      alias push concat
+      alias << concat
+    end
+  end
+end

data/lib/daru_lite/vector/missable.rb

@@ -0,0 +1,124 @@
+module DaruLite
+  class Vector
+    module Missable
+      extend Gem::Deprecate
+
+      # Reports whether missing data is present in the Vector.
+      def has_missing_data? # rubocop:disable Naming/PredicateName
+        !indexes(*DaruLite::MISSING_VALUES).empty?
+      end
+      alias flawed? has_missing_data?
+      deprecate :has_missing_data?, :include_values?, 2016, 10
+      deprecate :flawed?, :include_values?, 2016, 10
+
+      # Replace all nils in the vector with the value passed as an argument. Destructive.
+      # See #replace_nils for non-destructive version
+      #
+      # == Arguments
+      #
+      # * +replacement+ - The value which should replace all nils
+      def replace_nils!(replacement)
+        indexes(*DaruLite::MISSING_VALUES).each do |idx|
+          self[idx] = replacement
+        end
+
+        self
+      end
+
+      # Rolling fillna
+      # replace all Float::NAN and NIL values with the preceeding or following value
+      #
+      # @param direction [Symbol] (:forward, :backward) whether replacement value is preceeding or following
+      #
+      # @example
+      #  dv = DaruLite::Vector.new([1, 2, 1, 4, nil, Float::NAN, 3, nil, Float::NAN])
+      #
+      #   2.3.3 :068 > dv.rolling_fillna(:forward)
+      #   => #<DaruLite::Vector(9)>
+      #   0   1
+      #   1   2
+      #   2   1
+      #   3   4
+      #   4   4
+      #   5   4
+      #   6   3
+      #   7   3
+      #   8   3
+      #
+      def rolling_fillna!(direction = :forward)
+        enum = direction == :forward ? index : index.reverse_each
+        last_valid_value = 0
+        enum.each do |idx|
+          if valid_value?(self[idx])
+            last_valid_value = self[idx]
+          else
+            self[idx] = last_valid_value
+          end
+        end
+        self
+      end
+
+      # Non-destructive version of rolling_fillna!
+      def rolling_fillna(direction = :forward)
+        dup.rolling_fillna!(direction)
+      end
+
+      # Non-destructive version of #replace_nils!
+      def replace_nils(replacement)
+        dup.replace_nils!(replacement)
+      end
+
+      # number of non-missing elements
+      def n_valid
+        size - indexes(*DaruLite::MISSING_VALUES).size
+      end
+      deprecate :n_valid, :count_values, 2016, 10
+
+      # Creates a new vector consisting only of non-nil data
+      #
+      # == Arguments
+      #
+      # @param as_a [Symbol] Passing :array will return only the elements
+      # as an Array. Otherwise will return a DaruLite::Vector.
+      #
+      # @param _duplicate [Symbol] In case no missing data is found in the
+      # vector, setting this to false will return the same vector.
+      # Otherwise, a duplicate will be returned irrespective of
+      # presence of missing data.
+
+      def only_valid(as_a = :vector, _duplicate = true) # rubocop:disable Style/OptionalBooleanParameter
+        # FIXME: Now duplicate is just ignored.
+        #   There are no spec that fail on this case, so I'll leave it
+        #   this way for now - zverok, 2016-05-07
+
+        new_index = @index.to_a - indexes(*DaruLite::MISSING_VALUES)
+        new_vector = new_index.map { |idx| self[idx] }
+
+        if as_a == :vector
+          DaruLite::Vector.new new_vector, index: new_index, name: @name, dtype: dtype
+        else
+          new_vector
+        end
+      end
+      deprecate :only_valid, :reject_values, 2016, 10
+
+      # Returns a Vector containing only missing data (preserves indexes).
+      def only_missing(as_a = :vector)
+        case as_a
+        when :vector
+          self[*indexes(*DaruLite::MISSING_VALUES)]
+        when :array
+          self[*indexes(*DaruLite::MISSING_VALUES)].to_a
+        end
+      end
+      deprecate :only_missing, nil, 2016, 10
+
+      private
+
+      # Helper method returning validity of arbitrary value
+      def valid_value?(v)
+        !((v.respond_to?(:nan?) && v.nan?) || v.nil?)
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/queryable.rb

@@ -0,0 +1,45 @@
+module DaruLite
+  class Vector
+    module Queryable
+      def empty?
+        @index.empty?
+      end
+
+      # Check if any one of mentioned values occur in the vector
+      # @param values  [Array] values to check for
+      # @return [true, false] returns true if any one of specified values
+      #   occur in the vector
+      # @example
+      #   dv = DaruLite::Vector.new [1, 2, 3, 4, nil]
+      #   dv.include_values? nil, Float::NAN
+      #   # => true
+      def include_values?(*values)
+        values.any? { |v| include_with_nan? @data, v }
+      end
+
+      def any?(&block)
+        @data.data.any?(&block)
+      end
+
+      def all?(&block)
+        @data.data.all?(&block)
+      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 = DaruLite::Vector.new(['3 days', '5 weeks', '2 weeks'])
+      #   dv.match(/weeks/)
+      #
+      #   # => [false, true, true]
+      def match(regexp)
+        @data.map { |value| !!(value =~ regexp) }
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/setable.rb

@@ -0,0 +1,47 @@
+module DaruLite
+  class Vector
+    module Setable
+      # Change value at given positions
+      # @param positions [Array<object>] positional values
+      # @param [object] val value to assign
+      # @example
+      #   dv = DaruLite::Vector.new 'a'..'e'
+      #   dv.set_at [0, 1], 'x'
+      #   dv
+      #   # => #<DaruLite::Vector(5)>
+      #   #   0   x
+      #   #   1   x
+      #   #   2   c
+      #   #   3   d
+      #   #   4   e
+      def set_at(positions, val)
+        validate_positions(*positions)
+        positions.map { |pos| @data[pos] = val }
+        update_position_cache
+      end
+
+      # Just like in Hashes, you can specify the index label of the DaruLite::Vector
+      # and assign an element an that place in the DaruLite::Vector.
+      #
+      # == Usage
+      #
+      #   v = DaruLite::Vector.new([1,2,3], index: [:a, :b, :c])
+      #   v[:a] = 999
+      #   #=>
+      #   ##<DaruLite::Vector:90257920 @name = nil @size = 3 >
+      #   #    nil
+      #   #  a 999
+      #   #  b   2
+      #   #  c   3
+      def []=(*indexes, val)
+        cast(dtype: :array) if val.nil? && dtype != :array
+
+        guard_type_check(val)
+
+        modify_vector(indexes, val)
+
+        update_position_cache
+      end
+    end
+  end
+end

data/lib/daru_lite/vector/sortable.rb

@@ -0,0 +1,113 @@
+module DaruLite
+  class Vector
+    module Sortable
+      # Sorts a vector according to its values. If a block is specified, the contents
+      # will be evaluated and data will be swapped whenever the block evaluates
+      # to *true*. Defaults to ascending order sorting. Any missing values will be
+      # put at the end of the vector. Preserves indexing. Default sort algorithm is
+      # quick sort.
+      #
+      # == Options
+      #
+      # * +:ascending+ - if false, will sort in descending order. Defaults to true.
+      #
+      # * +:type+ - Specify the sorting algorithm. Only supports quick_sort for now.
+      # == Usage
+      #
+      #   v = DaruLite::Vector.new ["My first guitar", "jazz", "guitar"]
+      #   # Say you want to sort these strings by length.
+      #   v.sort(ascending: false) { |a,b| a.length <=> b.length }
+      def sort(opts = {}, &block)
+        opts = { ascending: true }.merge(opts)
+
+        vector_index = resort_index(@data.each_with_index, opts, &block)
+        vector, index = vector_index.transpose
+
+        index = @index.reorder index
+
+        DaruLite::Vector.new(vector, index: index, name: @name, dtype: @dtype)
+      end
+
+      # Sorts the vector according to it's`Index` values. Defaults to ascending
+      # order sorting.
+      #
+      # @param [Hash] opts the options for sort_by_index method.
+      # @option opts [Boolean] :ascending false, will sort `index` in
+      #  descending order.
+      #
+      # @return [Vector] new sorted `Vector` according to the index values.
+      #
+      # @example
+      #
+      #   dv = DaruLite::Vector.new [11, 13, 12], index: [23, 21, 22]
+      #   # Say you want to sort index in ascending order
+      #   dv.sort_by_index(ascending: true)
+      #   #=> DaruLite::Vector.new [13, 12, 11], index: [21, 22, 23]
+      #   # Say you want to sort index in descending order
+      #   dv.sort_by_index(ascending: false)
+      #   #=> DaruLite::Vector.new [11, 12, 13], index: [23, 22, 21]
+      def sort_by_index(opts = {})
+        opts = { ascending: true }.merge(opts)
+        _, new_order = resort_index(@index.each_with_index, opts).transpose
+
+        reorder new_order
+      end
+
+      DEFAULT_SORTER = lambda { |(lv, li), (rv, ri)|
+        if lv.nil? && rv.nil?
+          li <=> ri
+        elsif lv.nil?
+          -1
+        elsif rv.nil?
+          1
+        else
+          lv <=> rv
+        end
+      }
+
+      # Just sort the data and get an Array in return using Enumerable#sort.
+      # Non-destructive.
+      # :nocov:
+      def sorted_data(&block)
+        @data.to_a.sort(&block)
+      end
+      # :nocov:
+
+      # Reorder the vector with given positions
+      # @note Unlike #reindex! which takes index as input, it takes
+      #   positions as an input to reorder the vector
+      # @param [Array] order the order to reorder the vector with
+      # @return reordered vector
+      # @example
+      #   dv = DaruLite::Vector.new [3, 2, 1], index: ['c', 'b', 'a']
+      #   dv.reorder! [2, 1, 0]
+      #   # => #<DaruLite::Vector(3)>
+      #   #   a   1
+      #   #   b   2
+      #   #   c   3
+      def reorder!(order)
+        @index = @index.reorder order
+        data_array = order.map { |i| @data[i] }
+        @data = cast_vector_to @dtype, data_array, @nm_dtype
+        update_position_cache
+        self
+      end
+
+      # Non-destructive version of #reorder!
+      def reorder(order)
+        dup.reorder! order
+      end
+
+      private
+
+      def resort_index(vector_index, opts)
+        if block_given?
+          vector_index.sort { |(lv, _li), (rv, _ri)| yield(lv, rv) }
+        else
+          vector_index.sort(&DEFAULT_SORTER)
+        end
+          .tap { |res| res.reverse! unless opts[:ascending] }
+      end
+    end
+  end
+end