rover-df 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4588d0b3b5633a3821a4c07e7102e5933edca92179836db041f2400d8be88538
+  data.tar.gz: 9b01cd2bae5fb6ba9f426fe0d347752cd30c63619b00284fb68e8f711ec38ddf
+SHA512:
+  metadata.gz: b2d35866786a7fbe17b274585419c752b08c817b2db1bf939a6c3f92a7ae2cd282d725614f96db730fd2590cbb8c24710d0fb1f713255d2c348c0fed0b874a35
+  data.tar.gz: 4bf0ba38ce2c3ef4765d702591948af18fddf142efb7e559e26cc4ab504538775a1771c839f1570230f7d101fa20bfbbeb5044f6bf567637790575ee9b95be87

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2020-05-13)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,307 @@
+# Rover
+
+Simple, powerful data frames for Ruby
+
+:mountain: Designed for data exploration and machine learning, and powered by [Numo](https://github.com/ruby-numo/numo-narray) for blazing performance
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'rover-df'
+```
+
+## Intro
+
+A data frame is an in-memory table. It’s a useful data structure for data analysis and machine learning. It uses columnar storage for fast operations on columns.
+
+## Creating Data Frames
+
+From an array
+
+```ruby
+Rover::DataFrame.new([{a: 1, b: "one"}, {a: 2, b: "two"}, {a: 3, b: "three"}])
+```
+
+From a hash
+
+```ruby
+Rover::DataFrame.new({
+  a: [1, 2, 3],
+  b: ["one", "two", "three"]
+})
+```
+
+From an Active Record relation
+
+```ruby
+Rover::DataFrame.new(User.all)
+```
+
+From a CSV
+
+```ruby
+Rover.read_csv("file.csv")
+# or
+Rover.parse_csv("CSV,data,string")
+```
+
+## Attributes
+
+Get number of rows
+
+```ruby
+df.count
+```
+
+Get column names
+
+```ruby
+df.keys
+```
+
+Check if a column exists
+
+```ruby
+df.include?(name)
+```
+
+## Selecting Data
+
+Select a column
+
+```ruby
+df[:a]
+```
+
+Select multiple columns
+
+```ruby
+df[[:a, :b]]
+```
+
+Select first rows
+
+```ruby
+df.head
+# or
+df.first(5)
+```
+
+Select last rows
+
+```ruby
+df.tail
+# or
+df.last(5)
+```
+
+Select rows by index
+
+```ruby
+df[1]
+# or
+df[1..3]
+# or
+df[[1, 4, 5]]
+```
+
+## Filtering
+
+Filter on a condition
+
+```ruby
+df[df[:a] > 100]
+```
+
+And
+
+```ruby
+df[df[:a] > 100 & df[:b] == "one"]
+```
+
+Or
+
+```ruby
+df[df[:a] > 100 | df[:b] == "one"]
+```
+
+Not
+
+```ruby
+df[df[:a] != 100]
+```
+
+## Operations
+
+Basic operations
+
+```ruby
+df[:a] + 5
+df[:a] - 5
+df[:a] * 5
+df[:a] / 5
+df[:a] % 5
+df[:a] ** 2
+```
+
+Summary statistics
+
+```ruby
+df[:a].count
+df[:a].sum
+df[:a].mean
+df[:a].median
+df[:a].percentile(90)
+df[:a].min
+df[:a].max
+```
+
+Cross tabulation
+
+```ruby
+df[:a].crosstab(df[:b])
+```
+
+## Updates
+
+Add a new column
+
+```ruby
+df[:a] = 1
+# or
+df[:a] = [1, 2, 3]
+```
+
+Update a single element
+
+```ruby
+df[:a][0] = 100
+```
+
+Update multiple elements
+
+```ruby
+df[:a][0..2] = 1
+# or
+df[:a][0..2] = [1, 2, 3]
+```
+
+Update elements matching a condition
+
+```ruby
+df[:a][df[:a] > 100] = 0
+```
+
+Clamp
+
+```ruby
+df[:a].clamp!(0, 100)
+```
+
+Delete columns
+
+```ruby
+df.delete(:a)
+# or
+df.except!(:a, :b)
+```
+
+Rename a column
+
+```ruby
+df[:new_a] = df.delete(:a)
+```
+
+Sort data
+
+```ruby
+df.sort_by! { |r| r[:a] }
+```
+
+Clear all data
+
+```ruby
+df.clear
+```
+
+## Combining Data Frames
+
+Add rows
+
+```ruby
+df.concat(other_df)
+```
+
+Add columns
+
+```ruby
+df.merge!(other_df)
+```
+
+Inner join
+
+```ruby
+df.inner_join(other_df)
+# or
+df.inner_join(other_df, on: :a)
+# or
+df.inner_join(other_df, on: [:a, :b])
+# or
+df.inner_join(other_df, on: {df_col: :other_df_col})
+```
+
+Left join
+
+```ruby
+df.left_join(other_df)
+```
+
+## Conversion
+
+Array of hashes
+
+```ruby
+df.to_a
+```
+
+Hash of arrays
+
+```ruby
+df.to_h
+```
+
+Numo array
+
+```ruby
+df.to_numo
+```
+
+CSV
+
+```ruby
+df.to_csv
+```
+
+## History
+
+View the [changelog](https://github.com/ankane/rover/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/rover/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/rover/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/rover.git
+cd rover
+bundle install
+bundle exec rake test
+```

data/lib/rover-df.rb

@@ -0,0 +1 @@
+require "rover"

data/lib/rover.rb

@@ -0,0 +1,32 @@
+# dependencies
+require "numo/narray"
+
+# modules
+require "rover/data_frame"
+require "rover/vector"
+require "rover/version"
+
+module Rover
+  class << self
+    def read_csv(path, **options)
+      require "csv"
+      csv_to_df(CSV.read(path, headers: true, converters: :numeric, **options))
+    end
+
+    def parse_csv(str, **options)
+      require "csv"
+      csv_to_df(CSV.parse(str, headers: true, converters: :numeric, **options))
+    end
+
+    private
+
+    def csv_to_df(table)
+      table.by_col!
+      data = {}
+      table.each do |k, v|
+        data[k] = v
+      end
+      DataFrame.new(data)
+    end
+  end
+end

data/lib/rover/data_frame.rb

@@ -0,0 +1,398 @@
+module Rover
+  class DataFrame
+    def initialize(data = {})
+      @vectors = {}
+
+      if data.is_a?(DataFrame)
+        data.vectors.each do |k, v|
+          @vectors[k] = v
+        end
+      elsif data.is_a?(Hash)
+        data.to_h.each do |k, v|
+          @vectors[k] =
+            if v.respond_to?(:to_a)
+              Vector.new(v)
+            else
+              v
+            end
+        end
+
+        # handle scalars
+        size = @vectors.values.find { |v| v.is_a?(Vector) }&.size || 1
+        @vectors.each_key do |k|
+          @vectors[k] = to_vector(@vectors[k], size)
+        end
+      elsif data.is_a?(Array)
+        vectors = {}
+        raise ArgumentError, "Array elements must be hashes" unless data.all? { |d| d.is_a?(Hash) }
+        keys = data.flat_map(&:keys).uniq
+        keys.each do |k|
+          vectors[k] = []
+        end
+        data.each do |d|
+          keys.each do |k|
+            vectors[k] << d[k]
+          end
+        end
+        vectors.each do |k, v|
+          @vectors[k] = to_vector(v)
+        end
+      elsif defined?(ActiveRecord) && (data.is_a?(ActiveRecord::Relation) || (data.is_a?(Class) && data < ActiveRecord::Base))
+        result = data.connection.select_all(data.all.to_sql)
+        result.columns.each_with_index do |k, i|
+          @vectors[k] = to_vector(result.rows.map { |r| r[i] })
+        end
+      else
+        raise ArgumentError, "Cannot cast to data frame: #{data.class.name}"
+      end
+
+      # check keys
+      @vectors.each_key do |k|
+        check_key(k)
+      end
+
+      # check sizes
+      sizes = @vectors.values.map(&:size).uniq
+      if sizes.size > 1
+        raise ArgumentError, "Different sizes: #{sizes}"
+      end
+    end
+
+    def [](where)
+      if (where.is_a?(Vector) && where.to_numo.is_a?(Numo::Bit)) || where.is_a?(Numeric) || where.is_a?(Range) || (where.is_a?(Array) && where.all? { |v| v.is_a?(Integer) } )
+        new_vectors = {}
+        @vectors.each do |k, v|
+          new_vectors[k] = v[where]
+        end
+        DataFrame.new(new_vectors)
+      elsif where.is_a?(Array)
+        # multiple columns
+        df = DataFrame.new
+        where.each do |k|
+          df[k] = @vectors[k]
+        end
+        df
+      else
+        # single column
+        @vectors[where]
+      end
+    end
+
+    # return each row as a hash
+    def each_row
+      size.times do |i|
+        yield @vectors.map { |k, v| [k, v[i]] }.to_h
+      end
+    end
+
+    # dup to prevent direct modification of keys
+    def vectors
+      @vectors.dup
+    end
+
+    def []=(k, v)
+      check_key(k)
+      v = to_vector(v, size)
+      raise ArgumentError, "Size mismatch: expected #{size}, got #{v.size}" if @vectors.any? && v.size != size
+      @vectors[k] = v
+    end
+
+    def size
+      @vectors.values.first&.size || 0
+    end
+    alias_method :length, :size
+    alias_method :count, :size
+
+    # should this check for columns as well?
+    def any?
+      size > 0
+    end
+
+    # should this check for columns as well?
+    def empty?
+      size == 0
+    end
+
+    def clear
+      @vectors.clear
+    end
+
+    def shape
+      [size, @vectors.size]
+    end
+
+    def keys
+      @vectors.keys
+    end
+    alias_method :names, :keys
+    alias_method :vector_names, :keys
+
+    def delete(key)
+      @vectors.delete(key)
+    end
+
+    def except(*keys)
+      dup.except!(*keys)
+    end
+
+    def except!(*keys)
+      keys.each do |key|
+        delete(key)
+      end
+      self
+    end
+
+    def include?(key)
+      @vectors.include?(key)
+    end
+
+    def head(n = 5)
+      first(n)
+    end
+
+    def tail(n = 5)
+      last(n)
+    end
+
+    def first(n = nil)
+      new_vectors = {}
+      @vectors.each do |k, v|
+        new_vectors[k] = v.first(n)
+      end
+      DataFrame.new(new_vectors)
+    end
+
+    def last(n = nil)
+      new_vectors = {}
+      @vectors.each do |k, v|
+        new_vectors[k] = v.last(n)
+      end
+      DataFrame.new(new_vectors)
+    end
+
+    def to_a
+      a = []
+      each_row do |row|
+        a << row
+      end
+      a
+    end
+
+    def to_h
+      hsh = {}
+      @vectors.each do |k, v|
+        hsh[k] = v.to_a
+      end
+      hsh
+    end
+
+    def to_numo
+      Numo::NArray.column_stack(vectors.values.map(&:to_numo))
+    end
+
+    def to_csv
+      require "csv"
+      CSV.generate do |csv|
+        csv << keys
+        numo = vectors.values.map(&:to_numo)
+        size.times do |i|
+          csv << numo.map { |n| n[i] }
+        end
+      end
+    end
+
+    # for IRuby
+    def to_html
+      require "iruby"
+      IRuby::HTML.table(to_h)
+    end
+
+    # TODO handle long text better
+    def inspect
+      return "#<Rover::DataFrame>" if keys.empty?
+
+      lines = []
+      line_start = 0
+      spaces = 2
+
+      @vectors.each do |k, v|
+        v = v.first(5).to_a
+        width = ([k] + v).map(&:to_s).map(&:size).max
+        width = 3 if width < 3
+
+        if lines.empty? || lines[-2].map { |l| l.size + spaces }.sum + width > 120
+          line_start = lines.size
+          lines << []
+          [size, 5].min.times do |i|
+            lines << []
+          end
+          lines << [] if size > 5
+          lines << []
+        end
+
+        lines[line_start] << "%#{width}s" % k.to_s
+        v.each_with_index do |v2, i|
+          lines[line_start + 1 + i] << "%#{width}s" % v2.to_s
+        end
+        lines[line_start + 6] << "%#{width}s" % "..." if size > 5
+      end
+
+      lines.pop
+      lines.map { |l| l.join(" " * spaces) }.join("\n")
+    end
+    alias_method :to_s, :inspect # alias like hash
+
+    def sort_by!
+      indexes =
+        size.times.sort_by do |i|
+          yield @vectors.map { |k, v| [k, v[i]] }.to_h
+        end
+
+      @vectors.each do |k, v|
+        self[k] = v.to_numo.at(indexes)
+      end
+      self
+    end
+
+    def sort_by(&block)
+      dup.sort_by!(&block)
+    end
+
+    def dup
+      df = DataFrame.new
+      @vectors.each do |k, v|
+        df[k] = v
+      end
+      df
+    end
+
+    def +(other)
+      dup.concat(other)
+    end
+
+    # in-place, like Array#concat
+    # TODO make more performant
+    def concat(other)
+      raise ArgumentError, "Must be a data frame" unless other.is_a?(DataFrame)
+
+      size = self.size
+      vectors.each do |k, v|
+        @vectors[k] = Vector.new(v.to_a + (other[k] ? other[k].to_a : [nil] * other.size))
+      end
+      (other.vector_names - vector_names).each do |k|
+        @vectors[k] = Vector.new([nil] * size + other[k].to_a)
+      end
+      self
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      other.vectors.each do |k, v|
+        self[k] = v
+      end
+      self
+    end
+
+    # see join for options
+    def inner_join(other, on: nil)
+      join(other, on: on, how: "inner")
+    end
+
+    # see join for options
+    def left_join(other, on: nil)
+      join(other, on: on, how: "left")
+    end
+
+    # don't check types
+    def ==(other)
+      size == other.size &&
+      keys == other.keys &&
+      keys.all? { |k| self[k] == other[k] }
+    end
+
+    private
+
+    def check_key(key)
+      raise ArgumentError, "Key must be a string or symbol, got #{key.inspect}" unless key.is_a?(String) || key.is_a?(Symbol)
+    end
+
+    # TODO make more efficient
+    # TODO add option to prefix/suffix keys?
+    # Supports:
+    # - on: :key
+    # - on: [:key1, :key2]
+    # - on: {key1a: :key1b, key2a: :key2b}
+    def join(other, how:, on: nil)
+      self_on, other_on =
+        if on.is_a?(Hash)
+          [on.keys, on.values]
+        else
+          on ||= keys & other.keys
+          on = [on] unless on.is_a?(Array)
+          [on, on]
+        end
+
+      check_join_keys(self, self_on)
+      check_join_keys(other, other_on)
+
+      indexed = other.to_a.group_by { |r| r.values_at(*other_on) }
+      indexed.default = []
+
+      left = how == "left"
+
+      vectors = {}
+      keys = (self.keys + other.keys).uniq
+      keys.each do |k|
+        vectors[k] = []
+      end
+
+      each_row do |r|
+        matches = indexed[r.values_at(*self_on)]
+        if matches.empty?
+          if left
+            keys.each do |k|
+              vectors[k] << r[k]
+            end
+          end
+        else
+          matches.each do |r2|
+            keys.each do |k|
+              vectors[k] << (r2[k] || r[k])
+            end
+          end
+        end
+      end
+
+      DataFrame.new(vectors)
+    end
+
+    def check_join_keys(df, keys)
+      raise ArgumentError, "No keys" if keys.empty?
+      missing_keys = keys.select { |k| !df.include?(k) }
+      raise ArgumentError, "Missing keys: #{missing_keys.join(", ")}" if missing_keys.any?
+    end
+
+    def to_vector(v, size = nil)
+      return v if v.is_a?(Vector)
+
+      if size && !v.respond_to?(:to_a)
+        v =
+          if v.is_a?(Integer)
+            Numo::Int64.new(size).fill(v)
+          elsif v.is_a?(Numeric)
+            Numo::DFloat.new(size).fill(v)
+          elsif v == true || v == false
+            Numo::Bit.new(size).fill(v)
+          else
+            # TODO make more efficient
+            [v] * size
+          end
+      end
+
+      Vector.new(v)
+    end
+  end
+end

data/lib/rover/vector.rb

@@ -0,0 +1,248 @@
+module Rover
+  class Vector
+    def initialize(data)
+      @data =
+        if data.is_a?(Vector)
+          data.to_numo
+        elsif data.is_a?(Numo::NArray)
+          data
+        else
+          data = data.to_a
+          if data.all? { |v| v.is_a?(Integer) }
+            Numo::Int64.cast(data)
+          elsif data.all? { |v| v.is_a?(Numeric) || v.nil? }
+            Numo::DFloat.cast(data.map { |v| v || Float::NAN })
+          elsif data.all? { |v| v == true || v == false }
+            Numo::Bit.cast(data)
+          else
+            Numo::RObject.cast(data)
+          end
+        end
+
+      raise ArgumentError, "Bad size: #{@data.shape}" unless @data.ndim == 1
+    end
+
+    def to_numo
+      @data
+    end
+
+    def to_a
+      a = @data.to_a
+      a.map! { |v| !v.zero? } if @data.is_a?(Numo::Bit)
+      a
+    end
+
+    def size
+      @data.size
+    end
+
+    def uniq
+      Vector.new(@data.to_a.uniq)
+    end
+
+    def missing
+      bit =
+        if @data.is_a?(Numo::RObject)
+          Numo::Bit.cast(@data.map(&:nil?))
+        elsif @data.respond_to?(:isnan)
+          @data.isnan
+        else
+          Numo::Bit.new(size).fill(0)
+        end
+
+      Vector.new(bit)
+    end
+
+    # keep same number of rows as original
+    # to make it easy to add to original data frame
+    def diff
+      diff = @data.cast_to(Numo::DFloat).diff
+      Vector.new(diff.insert(0, Float::NAN))
+    end
+
+    def [](v)
+      if v.is_a?(Vector)
+        Vector.new(v.to_numo.mask(@data))
+      else
+        @data[v]
+      end
+    end
+
+    def []=(k, v)
+      k = k.to_numo if k.is_a?(Vector)
+      @data[k] = v
+    end
+
+    %w(+ - * / % ** &).each do |op|
+      define_method(op) do |other|
+        other = other.to_numo if other.is_a?(Vector)
+        # TODO better logic
+        if @data.is_a?(Numo::RObject)
+          map { |v| v.send(op, other) }
+        else
+          Vector.new(@data.send(op, other))
+        end
+      end
+    end
+
+    {
+      "==" => "eq",
+      "!=" => "ne",
+      ">" => "gt",
+      ">=" => "ge",
+      "<" => "lt",
+      "<=" => "le"
+    }.each do |op, meth|
+      define_method(op) do |other|
+        other = other.to_numo if other.is_a?(Vector)
+        v =
+          if other.is_a?(Numo::RObject)
+            @data.to_a.zip(other).map { |v, ov| v == ov }
+          elsif other.is_a?(Numeric) || other.is_a?(Numo::NArray)
+            @data.send(meth, other)
+          else
+            @data.map { |v| v.send(op, other) }
+          end
+        Vector.new(Numo::Bit.cast(v))
+      end
+    end
+
+    def in?(values)
+      ret = Numo::Bit.new(size).fill(false)
+      values.each do |v|
+        comp =
+          if v.is_a?(Numeric) || v.is_a?(Numo::NArray)
+            @data.eq(v)
+          else
+            Numo::Bit.cast(@data.map { |d| d == v })
+          end
+        ret |= comp
+      end
+      Vector.new(ret)
+    end
+
+    def !
+      if @data.is_a?(Numo::Bit)
+        Vector.new(@data.eq(0))
+      else
+        raise "Not implemented yet"
+      end
+    end
+
+    def -@
+      self * -1
+    end
+
+    def clamp!(min, max)
+      @data = @data.clip(min, max)
+      self
+    end
+
+    def clamp(min, max)
+      dup.clamp!(min, max)
+    end
+
+    def map(&block)
+      mapped = @data.map(&block)
+      mapped = mapped.to_a if mapped.is_a?(Numo::RObject) # re-evaluate cast
+      Vector.new(mapped)
+    end
+
+    def sort
+      Vector.new(@data.respond_to?(:sort) ? @data.sort : @data.to_a.sort)
+    end
+
+    def abs
+      Vector.new(@data.abs)
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def max
+      @data.max
+    end
+
+    def min
+      @data.min
+    end
+
+    def mean
+      # currently only floats have mean in Numo
+      # https://github.com/ruby-numo/numo-narray/issues/79
+      @data.cast_to(Numo::DFloat).mean
+    end
+
+    def median
+      # need to cast to get correct result
+      # TODO file bug with Numo
+      @data.cast_to(Numo::DFloat).median
+    end
+
+    def percentile(q)
+      @data.percentile(q)
+    end
+
+    def sum
+      @data.sum
+    end
+
+    def all?(&block)
+      @data.to_a.all?(&block)
+    end
+
+    def any?(&block)
+      @data.to_a.any?(&block)
+    end
+
+    def first(n = 1)
+      if n >= size
+        Vector.new(@data)
+      else
+        Vector.new(@data[0...n])
+      end
+    end
+
+    def last(n = 1)
+      Vector.new(@data[-n..-1])
+    end
+
+    def crosstab(other)
+      index = uniq.sort
+      index_pos = index.to_a.map.with_index.to_h
+      df = DataFrame.new({"_" => index})
+      other.uniq.sort.each do |k|
+        df[k] = 0
+      end
+      to_a.zip(other.to_a) do |v1, v2|
+        df[v2][index_pos[v1]] += 1
+      end
+      df
+    end
+
+    def head(n = 5)
+      n += size if n < 0
+      first(n)
+    end
+
+    def tail(n = 5)
+      n += size if n < 0
+      last(n)
+    end
+
+    # TODO add type and size?
+    def inspect
+      elements = first(5).to_a.map(&:inspect)
+      elements << "..." if size > 5
+      "#<Rover::Vector [#{elements.join(", ")}]>"
+    end
+    alias_method :to_s, :inspect # alias like hash
+
+    # for IRuby
+    def to_html
+      require "iruby"
+      IRuby::HTML.table(to_a)
+    end
+  end
+end

data/lib/rover/version.rb

@@ -0,0 +1,3 @@
+module Rover
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: rover-df
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: iruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/rover-df.rb
+- lib/rover.rb
+- lib/rover/data_frame.rb
+- lib/rover/vector.rb
+- lib/rover/version.rb
+homepage: https://github.com/ankane/rover
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Simple, powerful data frames for Ruby
+test_files: []