daru_lite 0.1

data/lib/daru_lite/io/sql_data_source.rb

@@ -0,0 +1,97 @@
+module DaruLite
+  module IO
+    class SqlDataSource
+      # @private
+      class Adapter
+        def initialize(conn, query)
+          @conn = conn
+          @query = query
+        end
+
+        def result_hash
+          column_names
+            .map(&:to_sym)
+            .zip(rows.transpose)
+            .to_h
+        end
+      end
+
+      # Private adapter class for DBI::DatabaseHandle
+      # @private
+      class DbiAdapter < Adapter
+        private
+
+        def column_names
+          result.column_names
+        end
+
+        def rows
+          result.to_a.map(&:to_a)
+        end
+
+        def result
+          @result ||= @conn.execute(@query)
+        end
+      end
+
+      # Private adapter class for connections of ActiveRecord
+      # @private
+      class ActiveRecordConnectionAdapter < Adapter
+        private
+
+        def column_names
+          result.columns
+        end
+
+        def rows
+          result.cast_values
+        end
+
+        def result
+          @result ||= @conn.exec_query(@query)
+        end
+      end
+
+      private_constant :DbiAdapter
+      private_constant :ActiveRecordConnectionAdapter
+
+      def self.make_dataframe(db, query)
+        new(db, query).make_dataframe
+      end
+
+      def initialize(db, query)
+        @adapter = init_adapter(db, query)
+      end
+
+      def make_dataframe
+        DaruLite::DataFrame.new(@adapter.result_hash).tap(&:update)
+      end
+
+      private
+
+      def init_adapter(db, query)
+        query = String.try_convert(query) or
+          raise ArgumentError, "Query must be a string, #{query.class} received"
+
+        db = attempt_sqlite3_connection(db) if db.is_a?(String) && Pathname(db).exist?
+
+        case db
+        when DBI::DatabaseHandle
+          DbiAdapter.new(db, query)
+        when ActiveRecord::ConnectionAdapters::AbstractAdapter
+          ActiveRecordConnectionAdapter.new(db, query)
+        else
+          raise ArgumentError, "Unknown database adapter type #{db.class}"
+        end
+      end
+
+      def attempt_sqlite3_connection(db)
+        DBI.connect("DBI:SQLite3:#{db}")
+      rescue SQLite3::NotADatabaseException
+        raise ArgumentError, "Expected #{db} to point to a SQLite3 database"
+      rescue NameError
+        raise NameError, "In order to establish a connection to #{db}, please require 'dbi'"
+      end
+    end
+  end
+end

data/lib/daru_lite/iruby/helpers.rb

@@ -0,0 +1,38 @@
+module DaruLite
+  # @private
+  module IRuby
+    module Helpers
+      module_function
+
+      def tuples_with_rowspans(index)
+        index.sparse_tuples.transpose
+             .map { |r| nils_counted(r) }
+             .transpose.map(&:compact)
+      end
+
+      def tuples_with_colspans(index)
+        index.sparse_tuples.transpose
+             .map { |r| nils_counted(r) }
+             .map(&:compact)
+      end
+
+      # It is complicated, but the only algo I could think of.
+      # It does [:a, nil, nil, :b, nil, :c] # =>
+      #         [[:a,3], nil, nil, [:b,2], nil, :c]
+      # Needed by tuples_with_colspans/rowspans, which we need for pretty HTML
+      def nils_counted(array)
+        grouped = [[array.first]]
+        array[1..].each do |val|
+          if val
+            grouped << [val]
+          else
+            grouped.last << val
+          end
+        end
+        grouped.flat_map do |items|
+          [[items.first, items.count], *Array.new(items.count - 1)]
+        end
+      end
+    end
+  end
+end

data/lib/daru_lite/iruby/templates/dataframe.html.erb

@@ -0,0 +1,5 @@
+<b> DaruLite::DataFrame<%= name ? ": #{name} " : ''%>(<%=nrows%>x<%=ncols%>) </b>
+<table border="1" class="dataframe">
+  <%= table_thead %>
+  <%= table_tbody %>
+</table>

data/lib/daru_lite/iruby/templates/dataframe_mi.html.erb

@@ -0,0 +1,5 @@
+<b> DaruLite::DataFrame<%= name ? ": #{name} " : ''%>(<%=nrows%>x<%=ncols%>) </b>
+<table>
+  <%= table_thead %>
+  <%= table_tbody %>
+</table>

data/lib/daru_lite/iruby/templates/dataframe_mi_tbody.html.erb

@@ -0,0 +1,35 @@
+<tbody>
+  <% DaruLite::IRuby::Helpers.tuples_with_rowspans(@index).first(threshold).zip(@index.to_a).each do |tuple, index| %>
+    <tr>
+      <% tuple.each do |idx, span| %>
+        <th rowspan="<%= span %>"><%= idx %></th>
+      <% end %>
+      <% row[index].each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% if nrows > threshold %>
+    <tr>
+      <% index.width.times do %>
+        <th>...</th>
+      <% end %>
+      <% @vectors.size.times do %>
+        <td>...</td>
+      <% end %>
+    </tr>
+
+    <% last_index = @index.to_a.last
+       last_row = row[last_index] %>
+
+    <tr>
+      <% last_index.each do |idx| %>
+        <th><%= idx %></td>
+      <% end %>
+      <% last_row.each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+</tbody>

data/lib/daru_lite/iruby/templates/dataframe_mi_thead.html.erb

@@ -0,0 +1,21 @@
+<thead>
+  <% if @vectors.is_a? MultiIndex %>
+    <% DaruLite::IRuby::Helpers.tuples_with_colspans(@vectors).each_with_index do |tuple, idx| %>
+      <tr>
+        <% if idx.zero? %>
+          <th colspan="<%= index.width %>" rowspan="<%= @vectors.width %>"></th>
+        <% end %>
+        <% tuple.each do |idx, span| %>
+          <th colspan="<%= span %>"><%= idx %></th>
+        <% end %>
+      </tr>
+    <% end %>
+  <% else %>
+    <tr>
+      <th colspan="<%= index.width %>"></th>
+      <% @vectors.each do |vector| %>
+        <th><%=vector%></th>
+      <% end %>
+    </tr>
+  <% end %>
+</thead>

data/lib/daru_lite/iruby/templates/dataframe_tbody.html.erb

@@ -0,0 +1,28 @@
+<tbody>
+  <% @index.first(threshold).each_with_index do |index, pos| %>
+    <tr>
+      <td><%= index %></td>
+      <% row.at(pos).each do |element| %>
+        <td><%= element.to_s %></td>
+      <% end %>
+    </tr>
+  <% end %>
+
+  <% if nrows > threshold %>
+    <tr>
+      <% (@vectors.size + 1).times do %>
+        <td>...</td>
+      <% end %>
+    </tr>
+
+    <% last_index = @index.to_a.last
+       last_row = row_at @index.size-1 %>
+
+    <tr>
+      <td><%= last_index %></td>
+        <% last_row.each do |element| %>
+          <td><%= element.to_s %></td>
+        <% end %>
+    </tr>
+  <% end %>
+</tbody>

data/lib/daru_lite/iruby/templates/dataframe_thead.html.erb

@@ -0,0 +1,21 @@
+<thead>
+  <% if @vectors.is_a? MultiIndex %>
+    <% DaruLite::IRuby::Helpers.tuples_with_colspans(@vectors).each_with_index do |tuple, idx| %>
+      <tr>
+        <% if idx.zero? %>
+          <th rowspan="<%= @vectors.width %>"></th>
+        <% end %>
+        <% tuple.each do |idx, span| %>
+          <th colspan="<%= span %>"><%= idx %></th>
+        <% end %>
+      </tr>
+    <% end %>
+  <% else %>
+    <tr>
+      <th></th>
+      <% @vectors.each do |vector| %>
+        <th><%=vector%></th>
+      <% end %>
+    </tr>
+  <% end %>
+</thead>

data/lib/daru_lite/iruby/templates/multi_index.html.erb

@@ -0,0 +1,12 @@
+<table>
+  <tr>
+    <th colspan="<%= width %>">DaruLite::MultiIndex(<%= size %>x<%= width %>)</th>
+  </tr>
+  <% DaruLite::IRuby::Helpers.tuples_with_rowspans(self).each do |row| %>
+    <tr>
+      <% row.each do |val, span| %>
+        <th rowspan="<%= span %>"><%= val %></th>
+      <% end %>
+    </tr>
+  <% end %>
+</table>

data/lib/daru_lite/iruby/templates/vector.html.erb

@@ -0,0 +1,5 @@
+<b> DaruLite::Vector(<%= size %>)<%= ':category' if category? %> </b>
+<table>
+  <%= table_thead %>
+  <%= table_tbody %>
+</table>

data/lib/daru_lite/iruby/templates/vector_mi.html.erb

@@ -0,0 +1,5 @@
+<b> DaruLite::Vector(<%= size %>)<%= ':category' if category? %> </b>
+<table>
+  <%= table_thead %>
+  <%= table_tbody %>
+</table>

data/lib/daru_lite/iruby/templates/vector_mi_tbody.html.erb

@@ -0,0 +1,26 @@
+<tbody>
+  <% DaruLite::IRuby::Helpers.tuples_with_rowspans(@index).first(threshold).zip(to_a).each do |tuple, value| %>
+    <tr>
+      <% tuple.each do |idx, span| %>
+        <th rowspan="<%= span %>"><%= idx %></th>
+      <% end %>
+      <td><%= value %></td>
+    </tr>
+  <% end %>
+
+  <% if size > threshold %>
+    <% last_index = @index.to_a.last %>
+    <tr>
+      <% last_index.size.times do %>
+        <th>...</th>
+      <% end %>
+      <td>...</td>
+    </tr>
+    <tr>
+      <% last_index.each do |idx| %>
+        <th><%= idx %></td>
+      <% end %>
+      <td><%= self[last_index] %></td>
+    </tr>
+  <% end %>
+</tbody>

data/lib/daru_lite/iruby/templates/vector_mi_thead.html.erb

@@ -0,0 +1,8 @@
+<thead>
+  <% if name %>
+    <tr>
+        <th colspan="<%= index.width %>"> </th>
+        <th><%= name %></th>
+    </tr>
+  <% end %>
+</thead>

data/lib/daru_lite/iruby/templates/vector_tbody.html.erb

@@ -0,0 +1,17 @@
+<tbody>
+  <% @index.each_with_index.first(threshold).each do |index, pos| %>
+    <tr>
+      <td><%= index %></td>
+      <td><%= self.at(pos) %></td>
+    </tr>
+  <% end %>
+
+  <% if size > threshold %>
+    <% last_index = @index.size-1 %>
+    <tr><td>...</td><td>...</td></tr>
+    <tr>
+      <td><%= last_index %></td>
+      <td><%= self.at last_index %></td>
+    </tr>
+  <% end %>
+</tbody>

data/lib/daru_lite/iruby/templates/vector_thead.html.erb

@@ -0,0 +1,8 @@
+<thead>
+  <% if name %>
+    <tr>
+        <th> </th>
+        <th><%= name %></th>
+    </tr>
+  <% end %>
+</thead>

data/lib/daru_lite/maths/arithmetic/dataframe.rb

@@ -0,0 +1,91 @@
+module DaruLite
+  module Maths
+    # Module encapsulating all aritmetic methods on DataFrame.
+    module Arithmetic
+      module DataFrame
+        # Add a scalar or another DataFrame
+        def +(other)
+          binary_operation :+, other
+        end
+
+        # Subtract a scalar or another DataFrame.
+        def -(other)
+          binary_operation :-, other
+        end
+
+        # Multiply a scalar or another DataFrame.
+        def *(other)
+          binary_operation :*, other
+        end
+
+        # Divide a scalar or another DataFrame.
+        def /(other)
+          binary_operation :/, other
+        end
+
+        # Modulus with a scalar or another DataFrame.
+        def %(other)
+          binary_operation :%, other
+        end
+
+        # Exponent with a scalar or another DataFrame.
+        def **(other)
+          binary_operation :**, other
+        end
+
+        # Calculate exponenential of all vectors with numeric values.
+        def exp
+          only_numerics(clone: false).recode(&:exp)
+        end
+
+        # Calcuate square root of numeric vectors.
+        def sqrt
+          only_numerics(clone: false).recode(&:sqrt)
+        end
+
+        def round(precision = 0)
+          only_numerics(clone: false).recode { |v| v.round(precision) }
+        end
+
+        private
+
+        def binary_operation(operation, other)
+          case other
+          when DaruLite::DataFrame
+            dataframe_binary_operation operation, other
+          else
+            scalar_binary_operation operation, other
+          end
+        end
+
+        def dataframe_binary_operation(operation, other)
+          all_vectors = (vectors.to_a | other.vectors.to_a).sort
+          all_indexes = (index.to_a   | other.index.to_a).sort
+
+          hsh =
+            all_vectors.to_h do |vector_name|
+              vector = dataframe_binary_operation_on_vectors other, vector_name, operation, all_indexes
+
+              [vector_name, vector]
+            end
+
+          DaruLite::DataFrame.new(hsh, index: all_indexes, name: @name, dtype: @dtype)
+        end
+
+        def dataframe_binary_operation_on_vectors(other, name, operation, indexes)
+          if has_vector?(name) && other.has_vector?(name)
+            self[name].send(operation, other[name])
+          else
+            DaruLite::Vector.new([], index: indexes, name: name)
+          end
+        end
+
+        def scalar_binary_operation(operation, other)
+          dup.map_vectors! do |vector|
+            vector.numeric? ? vector.send(operation, other) : vector
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module DaruLite
+  module Maths
+    module Arithmetic
+      module Vector
+        def +(other)
+          binary_op :+, other
+        end
+
+        def -(other)
+          binary_op :-, other
+        end
+
+        def *(other)
+          binary_op :*, other
+        end
+
+        def /(other)
+          binary_op :/, other
+        end
+
+        def %(other)
+          binary_op :%, other
+        end
+
+        def **(other)
+          binary_op :**, other
+        end
+
+        def exp
+          math_unary_op :exp
+        end
+
+        def sqrt
+          math_unary_op :sqrt
+        end
+
+        def abs
+          recode { |e| e&.abs }
+        end
+
+        def round(precision = 0)
+          recode { |e| e&.round(precision) }
+        end
+
+        # Add specified vector.
+        #
+        # @param other [DaruLite::Vector] The vector thats added to this.
+        # @param opts [Boolean] :skipnil if true treats nils as 0.
+        #
+        # @example
+        #
+        #    v0 = DaruLite::Vector.new [1, 2, nil, nil]
+        #    v1 = DaruLite::Vector.new [2, 1, 3, nil]
+        #
+        #    irb> v0.add v1
+        #    =>  #<DaruLite::Vector(4)>
+        #          0   3
+        #          1   3
+        #          2 nil
+        #          3 nil
+        #
+        #    irb> v0.add v1, skipnil: true
+        #    =>  #<DaruLite::Vector(4)>
+        #          0   3
+        #          1   3
+        #          2   3
+        #          3   0
+        #
+        def add(other, opts = {})
+          v2v_binary :+, other, skipnil: opts.fetch(:skipnil, false)
+        end
+
+        private
+
+        def math_unary_op(operation)
+          recode { |e| Math.send(operation, e) unless e.nil? }
+        end
+
+        def binary_op(operation, other)
+          case other
+          when DaruLite::Vector
+            v2v_binary operation, other
+          else
+            v2o_binary operation, other
+          end
+        end
+
+        def v2o_binary(operation, other)
+          DaruLite::Vector.new map { |e| e&.send(operation, other) },
+                               name: @name, index: @index
+        end
+
+        def v2v_binary(operation, other, opts = {})
+          # FIXME: why the sorting?.. - zverok, 2016-05-18
+          index = ArrayHelper.sort_composite_data(@index.to_a | other.index.to_a)
+
+          elements = index.map do |idx|
+            this = self.index.include?(idx) ? self[idx] : nil
+            that = other.index.include?(idx) ? other[idx] : nil
+            this, that = zero_nil_args(this, that, opts.fetch(:skipnil, false))
+            this && that ? this.send(operation, that) : nil
+          end
+
+          DaruLite::Vector.new(elements, name: @name, index: index)
+        end
+
+        def zero_nil_args(this, that, skipnil)
+          if skipnil
+            this = 0 if this.nil?
+            that = 0 if that.nil?
+          end
+          [this, that]
+        end
+      end
+    end
+  end
+end