daru_lite 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f11fb1ea9fb6c3f43f5f8267338ed4cc81fde2f60bcc82fd6eec6e30b5d87d5
-  data.tar.gz: e8a833062efdf095672da6684d3971a5e1eafa482b658ae7436061ad4d9ff1c7
+  metadata.gz: 1fca8a59ee849230424502a8ffa2f986134ccf522d15d53ab3807c22b64b30f8
+  data.tar.gz: 8c4e8048ea8171c463b048ac9dff8b86a8b19e3ec5dd62f16bf72311e7b03b38
 SHA512:
-  metadata.gz: 25dc59ffa9fb012693cf7bd611e19d134d4f003ee3ff5c642a574cb4bfebc5001a8aacd8b42982001b585233b370017e440c62be9dc6389f371423edc36c058b
-  data.tar.gz: f7373e8a86deb1f766cfb56f759cce92accfad2b571dac138d6d2eb54c2bb746b9cb6a11854891ba4137740208310837cb06edef4680cc2d4319260b12a1c917
+  metadata.gz: 403d6cfe869dcd152f083ea0878be37f6a8b40212f6ba5f80ece21bcadf51a4f13471f529bbddcf66b593568f31ec52f3e308c39160f0bd87bac9af6d95b30f6
+  data.tar.gz: dfbc2d7b5e63c54980c704c0df3d96ae8d079b921fc0ff51a34f109126a2a382d531457321737e83a2b03bc114b741e3018d0beb9cb00554aa822345d94f3144

data/.rubocop_todo.yml

@@ -1,11 +1,19 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2022-08-16 13:20:50 UTC using RuboCop version 1.35.0.
+# on 2024-03-03 13:59:21 UTC using RuboCop version 1.60.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: aligned, indented
+Layout/LineEndStringConcatenationIndentation:
+  Exclude:
+    - 'lib/daru_lite/data_frame/indexable.rb'
+
 # Offense count: 1
 # Configuration parameters: AllowComments.
 Lint/EmptyClass:
@@ -13,6 +21,7 @@ Lint/EmptyClass:
     - 'lib/daru_lite/accessors/mdarray_wrapper.rb'
 
 # Offense count: 5
+# Configuration parameters: AllowedParentClasses.
 Lint/MissingSuper:
   Exclude:
     - 'lib/daru_lite/date_time/offsets.rb'
@@ -20,61 +29,50 @@ Lint/MissingSuper:
     - 'lib/daru_lite/index/index.rb'
     - 'lib/daru_lite/index/multi_index.rb'
 
-# Offense count: 6
+# Offense count: 5
+# This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: CheckForMethodsWithNoSideEffects.
 Lint/Void:
   Exclude:
     - 'lib/daru_lite/category.rb'
-    - 'lib/daru_lite/dataframe.rb'
+    - 'lib/daru_lite/data_frame/indexable.rb'
     - 'lib/daru_lite/vector.rb'
 
-# Offense count: 40
-# Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods, CountRepeatedAttributes.
+# Offense count: 41
+# Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes.
 Metrics/AbcSize:
   Max: 34
 
-# Offense count: 3
+# Offense count: 5
 # Configuration parameters: CountComments, CountAsOne.
 Metrics/ClassLength:
-  Max: 189
+  Max: 188
 
 # Offense count: 6
-# Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods.
+# Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/CyclomaticComplexity:
   Max: 9
 
-# Offense count: 61
-# Configuration parameters: CountComments, CountAsOne, ExcludedMethods, AllowedMethods, AllowedPatterns, IgnoredMethods.
+# Offense count: 60
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 15
 
-# Offense count: 2
+# Offense count: 4
 # Configuration parameters: CountComments, CountAsOne.
 Metrics/ModuleLength:
   Max: 190
 
 # Offense count: 4
-# Configuration parameters: AllowedMethods, AllowedPatterns, IgnoredMethods.
+# Configuration parameters: AllowedMethods, AllowedPatterns.
 Metrics/PerceivedComplexity:
   Max: 10
 
-# Offense count: 72
+# Offense count: 66
 # Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
-# AllowedNames: at, by, db, id, in, io, ip, of, on, os, pp, to
+# AllowedNames: as, at, by, cc, db, id, if, in, io, ip, of, on, os, pp, to
 Naming/MethodParameterName:
-  Exclude:
-    - 'lib/daru_lite/category.rb'
-    - 'lib/daru_lite/core/group_by.rb'
-    - 'lib/daru_lite/core/merge.rb'
-    - 'lib/daru_lite/core/query.rb'
-    - 'lib/daru_lite/dataframe.rb'
-    - 'lib/daru_lite/date_time/index.rb'
-    - 'lib/daru_lite/date_time/offsets.rb'
-    - 'lib/daru_lite/extensions/which_dsl.rb'
-    - 'lib/daru_lite/io/io.rb'
-    - 'lib/daru_lite/maths/statistics/dataframe.rb'
-    - 'lib/daru_lite/maths/statistics/vector.rb'
-    - 'lib/daru_lite/vector.rb'
+  Enabled: false
 
 # Offense count: 5
 # Configuration parameters: NamePrefix, ForbiddenPrefixes, AllowedMethods, MethodDefinitionMacros.
@@ -85,13 +83,14 @@ Naming/MethodParameterName:
 Naming/PredicateName:
   Exclude:
     - 'spec/**/*'
-    - 'lib/daru_lite/dataframe.rb'
+    - 'lib/daru_lite/data_frame/missable.rb'
+    - 'lib/daru_lite/data_frame/queryable.rb'
     - 'lib/daru_lite/vector.rb'
 
 # Offense count: 5
 Security/MarshalLoad:
   Exclude:
-    - 'lib/daru_lite/dataframe.rb'
+    - 'lib/daru_lite/data_frame/i_o_able.rb'
     - 'lib/daru_lite/date_time/index.rb'
     - 'lib/daru_lite/index/index.rb'
     - 'lib/daru_lite/io/io.rb'
@@ -102,7 +101,7 @@ Style/ClassVars:
   Exclude:
     - 'lib/daru_lite.rb'
 
-# Offense count: 44
+# Offense count: 58
 # Configuration parameters: AllowedConstants.
 Style/Documentation:
   Enabled: false
@@ -113,6 +112,10 @@ Style/MapToHash:
   Exclude:
     - 'lib/daru_lite/category.rb'
     - 'lib/daru_lite/core/group_by.rb'
+    - 'lib/daru_lite/data_frame/convertible.rb'
+    - 'lib/daru_lite/data_frame/duplicatable.rb'
+    - 'lib/daru_lite/data_frame/fetchable.rb'
+    - 'lib/daru_lite/data_frame/joinable.rb'
     - 'lib/daru_lite/dataframe.rb'
 
 # Offense count: 1
@@ -125,7 +128,7 @@ Style/MultilineBlockChain:
 # AllowedMethods: respond_to_missing?
 Style/OptionalBooleanParameter:
   Exclude:
-    - 'lib/daru_lite/dataframe.rb'
+    - 'lib/daru_lite/data_frame/convertible.rb'
     - 'lib/daru_lite/maths/statistics/vector.rb'
     - 'lib/daru_lite/vector.rb'
 
@@ -133,5 +136,4 @@ Style/OptionalBooleanParameter:
 # This cop supports unsafe autocorrection (--autocorrect-all).
 Style/RedundantSelfAssignment:
   Exclude:
-    - 'lib/daru_lite/dataframe.rb'
-
+    - 'lib/daru_lite/data_frame/joinable.rb'

data/lib/daru_lite/data_frame/aggregatable.rb

@@ -0,0 +1,165 @@
+module DaruLite
+  class DataFrame
+    module Aggregatable
+      # Group elements by vector to perform operations on them. Returns a
+      # DaruLite::Core::GroupBy object.See the DaruLite::Core::GroupBy docs for a detailed
+      # list of possible operations.
+      #
+      # == Arguments
+      #
+      # * vectors - An Array contatining names of vectors to group by.
+      #
+      # == Usage
+      #
+      #   df = DaruLite::DataFrame.new({
+      #     a: %w{foo bar foo bar   foo bar foo foo},
+      #     b: %w{one one two three two two one three},
+      #     c:   [1  ,2  ,3  ,1    ,3  ,6  ,3  ,8],
+      #     d:   [11 ,22 ,33 ,44   ,55 ,66 ,77 ,88]
+      #   })
+      #   df.group_by([:a,:b,:c]).groups
+      #   #=> {["bar", "one", 2]=>[1],
+      #   # ["bar", "three", 1]=>[3],
+      #   # ["bar", "two", 6]=>[5],
+      #   # ["foo", "one", 1]=>[0],
+      #   # ["foo", "one", 3]=>[6],
+      #   # ["foo", "three", 8]=>[7],
+      #   # ["foo", "two", 3]=>[2, 4]}
+      def group_by(*vectors)
+        vectors.flatten!
+        missing = vectors - @vectors.to_a
+        raise(ArgumentError, "Vector(s) missing: #{missing.join(', ')}") unless missing.empty?
+
+        vectors = [@vectors.first] if vectors.empty?
+
+        DaruLite::Core::GroupBy.new(self, vectors)
+      end
+
+      # Function to use for aggregating the data.
+      #
+      # @param options [Hash] options for column, you want in resultant dataframe
+      #
+      # @return [DaruLite::DataFrame]
+      #
+      # @example
+      #   df = DaruLite::DataFrame.new(
+      #      {col: [:a, :b, :c, :d, :e], num: [52,12,07,17,01]})
+      #   => #<DaruLite::DataFrame(5x2)>
+      #        col num
+      #      0   a  52
+      #      1   b  12
+      #      2   c   7
+      #      3   d  17
+      #      4   e   1
+      #
+      #    df.aggregate(num_100_times: ->(df) { (df.num*100).first })
+      #   => #<DaruLite::DataFrame(5x1)>
+      #               num_100_ti
+      #             0       5200
+      #             1       1200
+      #             2        700
+      #             3       1700
+      #             4        100
+      #
+      #   When we have duplicate index :
+      #
+      #   idx = DaruLite::CategoricalIndex.new [:a, :b, :a, :a, :c]
+      #   df = DaruLite::DataFrame.new({num: [52,12,07,17,01]}, index: idx)
+      #   => #<DaruLite::DataFrame(5x1)>
+      #        num
+      #      a  52
+      #      b  12
+      #      a   7
+      #      a  17
+      #      c   1
+      #
+      #   df.aggregate(num: :mean)
+      #   => #<DaruLite::DataFrame(3x1)>
+      #                      num
+      #             a 25.3333333
+      #             b         12
+      #             c          1
+      #
+      # Note: `GroupBy` class `aggregate` method uses this `aggregate` method
+      # internally.
+      def aggregate(options = {}, multi_index_level = -1)
+        if block_given?
+          positions_tuples, new_index = yield(@index) # NOTE: use of yield is private for now
+        else
+          positions_tuples, new_index = group_index_for_aggregation(@index, multi_index_level)
+        end
+
+        colmn_value = aggregate_by_positions_tuples(options, positions_tuples)
+
+        DaruLite::DataFrame.new(colmn_value, index: new_index, order: options.keys)
+      end
+
+      def group_by_and_aggregate(*group_by_keys, **aggregation_map)
+        group_by(*group_by_keys).aggregate(aggregation_map)
+      end
+
+      private
+
+      def aggregate_by_positions_tuples(options, positions_tuples)
+        agg_over_vectors_only, options = cast_aggregation_options(options)
+
+        if agg_over_vectors_only
+          options.map do |vect_name, method|
+            vect = self[vect_name]
+
+            positions_tuples.map do |positions|
+              vect.apply_method_on_sub_vector(method, keys: positions)
+            end
+          end
+        else
+          methods = options.values
+
+          # NOTE: because we aggregate over rows, we don't have to re-get sub-dfs for each method (which is expensive)
+          rows = positions_tuples.map do |positions|
+            apply_method_on_sub_df(methods, keys: positions)
+          end
+
+          rows.transpose
+        end
+      end
+
+      # convert operations over sub-vectors to operations over sub-dfs when it improves perf
+      # note: we don't always "cast" because aggregation over a single vector / a few vector is faster
+      #   than aggregation over (sub-)dfs
+      def cast_aggregation_options(options)
+        vects, non_vects = options.keys.partition { |k| @vectors.include?(k) }
+
+        over_vectors = true
+
+        if non_vects.any?
+          options = options.clone
+
+          vects.each do |name|
+            proc_on_vect = options[name].to_proc
+            options[name] = ->(sub_df) { proc_on_vect.call(sub_df[name]) }
+          end
+
+          over_vectors = false
+        end
+
+        [over_vectors, options]
+      end
+
+      def group_index_for_aggregation(index, multi_index_level = -1)
+        case index
+        when DaruLite::MultiIndex
+          groups_by_pos = DaruLite::Core::GroupBy.get_positions_group_for_aggregation(index, multi_index_level)
+
+          new_index = DaruLite::MultiIndex.from_tuples(groups_by_pos.keys).coerce_index
+          pos_tuples = groups_by_pos.values
+        when DaruLite::Index, DaruLite::CategoricalIndex
+          new_index = Array(index).uniq
+          pos_tuples = new_index.map { |idx| [*index.pos(idx)] }
+        else raise
+        end
+
+        [pos_tuples, new_index]
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/calculatable.rb

@@ -0,0 +1,140 @@
+module DaruLite
+  class DataFrame
+    module Calculatable
+      # Sum all numeric/specified vectors in the DataFrame.
+      #
+      # Returns a new vector that's a containing a sum of all numeric
+      # or specified vectors of the DataFrame. By default, if the vector
+      # contains a nil, the sum is nil.
+      # With :skipnil argument set to true, nil values are assumed to be
+      # 0 (zero) and the sum vector is returned.
+      #
+      # @param args [Array] List of vectors to sum. Default is nil in which case
+      #   all numeric vectors are summed.
+      #
+      # @option opts [Boolean] :skipnil Consider nils as 0. Default is false.
+      #
+      # @return Vector with sum of all vectors specified in the argument.
+      #   If vecs parameter is empty, sum all numeric vector.
+      #
+      # @example
+      #    df = DaruLite::DataFrame.new({
+      #       a: [1, 2, nil],
+      #       b: [2, 1, 3],
+      #       c: [1, 1, 1]
+      #     })
+      #    => #<DaruLite::DataFrame(3x3)>
+      #           a   b   c
+      #       0   1   2   1
+      #       1   2   1   1
+      #       2 nil   3   1
+      #    df.vector_sum [:a, :c]
+      #    => #<DaruLite::Vector(3)>
+      #       0   2
+      #       1   3
+      #       2 nil
+      #    df.vector_sum
+      #    => #<DaruLite::Vector(3)>
+      #       0   4
+      #       1   4
+      #       2 nil
+      #    df.vector_sum skipnil: true
+      #    => #<DaruLite::Vector(3)>
+      #           c
+      #       0   4
+      #       1   4
+      #       2   4
+      #
+      def vector_sum(*args)
+        defaults = { vecs: nil, skipnil: false }
+        options = args.last.is_a?(::Hash) ? args.pop : {}
+        options = defaults.merge(options)
+        vecs = args[0] || options[:vecs]
+        skipnil = args[1] || options[:skipnil]
+
+        vecs ||= numeric_vectors
+        sum = DaruLite::Vector.new [0] * @size, index: @index, name: @name, dtype: @dtype
+        vecs.inject(sum) { |memo, n| self[n].add(memo, skipnil: skipnil) }
+      end
+
+      # Calculate mean of the rows of the dataframe.
+      #
+      # == Arguments
+      #
+      # * +max_missing+ - The maximum number of elements in the row that can be
+      # zero for the mean calculation to happen. Default to 0.
+      def vector_mean(max_missing = 0)
+        # FIXME: in vector_sum we preserve created vector dtype, but
+        # here we are not. Is this by design or ...? - zverok, 2016-05-18
+        mean_vec = DaruLite::Vector.new [0] * @size, index: @index, name: "mean_#{@name}"
+
+        each_row_with_index.with_object(mean_vec) do |(row, i), memo|
+          memo[i] = row.indexes(*DaruLite::MISSING_VALUES).size > max_missing ? nil : row.mean
+        end
+      end
+
+      # Returns a vector, based on a string with a calculation based
+      # on vector.
+      #
+      # The calculation will be eval'ed, so you can put any variable
+      # or expression valid on ruby.
+      #
+      # For example:
+      #   a = DaruLite::Vector.new [1,2]
+      #   b = DaruLite::Vector.new [3,4]
+      #   ds = DaruLite::DataFrame.new({:a => a,:b => b})
+      #   ds.compute("a+b")
+      #   => Vector [4,6]
+      def compute(text, &block)
+        return instance_eval(&block) if block
+
+        instance_eval(text)
+      end
+
+      # DSL for yielding each row and returning a DaruLite::Vector based on the
+      # value each run of the block returns.
+      #
+      # == Usage
+      #
+      #   a1 = DaruLite::Vector.new([1, 2, 3, 4, 5, 6, 7])
+      #   a2 = DaruLite::Vector.new([10, 20, 30, 40, 50, 60, 70])
+      #   a3 = DaruLite::Vector.new([100, 200, 300, 400, 500, 600, 700])
+      #   ds = DaruLite::DataFrame.new({ :a => a1, :b => a2, :c => a3 })
+      #   total = ds.vector_by_calculation { a + b + c }
+      #   # <DaruLite::Vector:82314050 @name = nil @size = 7 >
+      #   #   nil
+      #   # 0 111
+      #   # 1 222
+      #   # 2 333
+      #   # 3 444
+      #   # 4 555
+      #   # 5 666
+      #   # 6 777
+      def vector_by_calculation(&block)
+        a = each_row.map { |r| r.instance_eval(&block) }
+
+        DaruLite::Vector.new a, index: @index
+      end
+
+      def vector_count_characters(vecs = nil)
+        vecs ||= @vectors.to_a
+
+        collect_rows do |row|
+          vecs.sum { |v| row[v].to_s.size }
+        end
+      end
+
+      # Generate a summary of this DataFrame based on individual vectors in the DataFrame
+      # @return [String] String containing the summary of the DataFrame
+      def summary
+        summary = "= #{name}"
+        summary << "\n  Number of rows: #{nrows}"
+        @vectors.each do |v|
+          summary << "\n  Element:[#{v}]\n"
+          summary << self[v].summary(1)
+        end
+        summary
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/convertible.rb

@@ -0,0 +1,107 @@
+module DaruLite
+  class DataFrame
+    module Convertible
+      # Create a sql, basen on a given Dataset
+      #
+      # == Arguments
+      #
+      # * table - String specifying name of the table that will created in SQL.
+      # * charset - Character set. Default is "UTF8".
+      #
+      # @example
+      #
+      #  ds = DaruLite::DataFrame.new({
+      #   :id   => DaruLite::Vector.new([1,2,3,4,5]),
+      #   :name => DaruLite::Vector.new(%w{Alex Peter Susan Mary John})
+      #  })
+      #  ds.create_sql('names')
+      #   #=>"CREATE TABLE names (id INTEGER,\n name VARCHAR (255)) CHARACTER SET=UTF8;"
+      #
+      def create_sql(table, charset = 'UTF8')
+        sql    = "CREATE TABLE #{table} ("
+        fields = vectors.to_a.collect do |f|
+          v = self[f]
+          "#{f} #{v.db_type}"
+        end
+
+        sql + fields.join(",\n ") + ") CHARACTER SET=#{charset};"
+      end
+
+      # Returns the dataframe.  This can be convenient when the user does not
+      # know whether the object is a vector or a dataframe.
+      # @return [self] the dataframe
+      def to_df
+        self
+      end
+
+      # Convert all vectors of type *:numeric* into a Matrix.
+      def to_matrix
+        Matrix.columns each_vector.select(&:numeric?).map(&:to_a)
+      end
+
+      # Converts the DataFrame into an array of hashes where key is vector name
+      # and value is the corresponding element. The 0th index of the array contains
+      # the array of hashes while the 1th index contains the indexes of each row
+      # of the dataframe. Each element in the index array corresponds to its row
+      # in the array of hashes, which has the same index.
+      def to_a
+        [each_row.map(&:to_h), @index.to_a]
+      end
+
+      # Convert to json. If no_index is false then the index will NOT be included
+      # in the JSON thus created.
+      def to_json(no_index = true)
+        if no_index
+          to_a[0].to_json
+        else
+          to_a.to_json
+        end
+      end
+
+      # Converts DataFrame to a hash (explicit) with keys as vector names and values as
+      # the corresponding vectors.
+      def to_h
+        @vectors
+          .each_with_index
+          .map { |vec_name, idx| [vec_name, @data[idx]] }.to_h
+      end
+
+      # Convert to html for IRuby.
+      def to_html(threshold = DaruLite.max_rows)
+        table_thead = to_html_thead
+        table_tbody = to_html_tbody(threshold)
+        path = if index.is_a?(MultiIndex)
+                 File.expand_path('../iruby/templates/dataframe_mi.html.erb', __dir__)
+               else
+                 File.expand_path('../iruby/templates/dataframe.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/dataframe_mi_thead.html.erb', __dir__)
+          else
+            File.expand_path('../iruby/templates/dataframe_thead.html.erb', __dir__)
+          end
+        ERB.new(File.read(table_thead_path).strip).result(binding)
+      end
+
+      def to_html_tbody(threshold = DaruLite.max_rows)
+        threshold ||= @size
+        table_tbody_path =
+          if index.is_a?(MultiIndex)
+            File.expand_path('../iruby/templates/dataframe_mi_tbody.html.erb', __dir__)
+          else
+            File.expand_path('../iruby/templates/dataframe_tbody.html.erb', __dir__)
+          end
+        ERB.new(File.read(table_tbody_path).strip).result(binding)
+      end
+
+      def to_s
+        "#<#{self.class}#{": #{@name}" if @name}(#{nrows}x#{ncols})>"
+      end
+    end
+  end
+end

data/lib/daru_lite/data_frame/duplicatable.rb

@@ -0,0 +1,64 @@
+module DaruLite
+  class DataFrame
+    module Duplicatable
+      extend Gem::Deprecate
+
+      # Duplicate the DataFrame entirely.
+      #
+      # == Arguments
+      #
+      # * +vectors_to_dup+ - An Array specifying the names of Vectors to
+      # be duplicated. Will duplicate the entire DataFrame if not specified.
+      def dup(vectors_to_dup = nil)
+        vectors_to_dup ||= @vectors.to_a
+
+        src = vectors_to_dup.map { |vec| @data[@vectors.pos(vec)].dup }
+        new_order = DaruLite::Index.new(vectors_to_dup)
+
+        DaruLite::DataFrame.new src, order: new_order, index: @index.dup, name: @name, clone: true
+      end
+
+      # Only clone the structure of the DataFrame.
+      def clone_structure
+        DaruLite::DataFrame.new([], order: @vectors.dup, index: @index.dup, name: @name)
+      end
+
+      # Returns a 'view' of the DataFrame, i.e the object ID's of vectors are
+      # preserved.
+      #
+      # == Arguments
+      #
+      # +vectors_to_clone+ - Names of vectors to clone. Optional. Will return
+      # a view of the whole data frame otherwise.
+      def clone(*vectors_to_clone)
+        vectors_to_clone.flatten! if ArrayHelper.array_of?(vectors_to_clone, Array)
+        vectors_to_clone = @vectors.to_a if vectors_to_clone.empty?
+
+        h = vectors_to_clone.map { |vec| [vec, self[vec]] }.to_h
+        DaruLite::DataFrame.new(h, clone: false, order: vectors_to_clone, name: @name)
+      end
+
+      # Returns a 'shallow' copy of DataFrame if missing data is not present,
+      # or a full copy of only valid data if missing data is present.
+      def clone_only_valid
+        if include_values?(*DaruLite::MISSING_VALUES)
+          reject_values(*DaruLite::MISSING_VALUES)
+        else
+          clone
+        end
+      end
+
+      # Creates a new duplicate dataframe containing only rows
+      # without a single missing value.
+      def dup_only_valid(vecs = nil)
+        rows_with_nil = @data.map { |vec| vec.indexes(*DaruLite::MISSING_VALUES) }
+                             .inject(&:concat)
+                             .uniq
+
+        row_indexes = @index.to_a
+        (vecs.nil? ? self : dup(vecs)).row[*(row_indexes - rows_with_nil)]
+      end
+      deprecate :dup_only_valid, :reject_values, 2016, 10
+    end
+  end
+end