daru_lite 0.1

data/lib/daru_lite/date_time/offsets.rb

@@ -0,0 +1,397 @@
+module DaruLite
+  # Generic class for generating date offsets.
+  class DateOffset
+    # A DaruLite::DateOffset object is created by a passing certain options
+    # to the constructor, which determine the kind of offset the object
+    # will support.
+    #
+    # You can pass one of the following options followed by their number
+    # to the DateOffset constructor:
+    #
+    # * :secs - Create a seconds offset
+    # * :mins - Create a minutes offset
+    # * :hours - Create an hours offset
+    # * :days  - Create a days offset
+    # * :weeks - Create a weeks offset
+    # * :months - Create a months offset
+    # * :years - Create a years offset
+    #
+    # Additionaly, passing the `:n` option will apply the offset that many times.
+    #
+    # @example Usage of DateOffset
+    #   # Create an offset of 3 weeks.
+    #   offset = DaruLite::DateOffset.new(weeks: 3)
+    #   offset + DateTime.new(2012,5,3)
+    #   #=> #<DateTime: 2012-05-24T00:00:00+00:00 ((2456072j,0s,0n),+0s,2299161j)>
+    #
+    #   # Create an offset of 5 hours
+    #   offset = DaruLite::DateOffset.new(hours: 5)
+    #   offset + DateTime.new(2015,3,3,23,5,1)
+    #   #=> #<DateTime: 2015-03-04T04:05:01+00:00 ((2457086j,14701s,0n),+0s,2299161j)>
+    #
+    #   # Create an offset of 2 minutes, applied 5 times
+    #   offset = DaruLite::DateOffset.new(mins: 2, n: 5)
+    #   offset + DateTime.new(2011,5,3,3,5)
+    #   #=> #<DateTime: 2011-05-03T03:15:00+00:00 ((2455685j,11700s,0n),+0s,2299161j)>
+    def initialize(opts = {})
+      n = opts[:n] || 1
+      Offsets::LIST.each do |key, klass|
+        if opts.key?(key)
+          @offset = klass.new(n * opts[key])
+          break
+        end
+      end
+
+      @offset = Offsets::Day.new(7 * n * opts[:weeks]) if opts[:weeks]
+    end
+
+    # Offset a DateTime forward.
+    #
+    # @param other [DateTime] A DateTime object which is to offset.
+    def +(other)
+      @offset + other
+    end
+
+    # Offset a DateTime backward.
+    #
+    # @param other [DateTime] A DateTime object which is to offset.
+    def -(other)
+      @offset - other
+    end
+
+    def -@
+      NegativeDateOffset.new(self)
+    end
+  end
+
+  class NegativeDateOffset
+    def initialize(offset)
+      @offset = offset
+    end
+
+    def +(other)
+      @offset - other
+    end
+
+    def -(other)
+      @offset + other
+    end
+
+    def -@
+      @offset
+    end
+  end
+
+  module Offsets
+    class DateOffsetType < DateOffset
+      # @!method initialize(n)
+      # Initialize one of the subclasses of DateOffsetType with the number of the times
+      # the offset should be applied, which is the supplied as the argument.
+      #
+      # @param n [Integer] The number of times an offset should be applied.
+      def initialize(n = 1)
+        @n = n
+      end
+
+      def freq_string
+        (@n == 1 ? '' : @n.to_s) + self.class::FREQ
+      end
+    end
+
+    # Private superclass for Offsets with equal inter-frequencies.
+    # @abstract
+    # @private
+    class Tick < DateOffsetType
+      def +(other)
+        other + (@n * multiplier)
+      end
+
+      def -(other)
+        other - (@n * multiplier)
+      end
+
+      def ==(other)
+        other.is_a?(Tick) && period == other.period
+      end
+
+      def period
+        @n * multiplier
+      end
+    end
+
+    # Create a seconds offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Seconds offset
+    #   offset = DaruLite::Offsets::Second.new(5)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2012-05-01T04:03:05+00:00 ((2456049j,14585s,0n),+0s,2299161j)>
+    class Second < Tick
+      FREQ = 'S'.freeze
+
+      def multiplier
+        1.to_r / 24 / 60 / 60
+      end
+    end
+
+    # Create a minutes offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Minutes offset
+    #   offset = DaruLite::Offsets::Minute.new(8)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2012-05-01T04:11:00+00:00 ((2456049j,15060s,0n),+0s,2299161j)>
+    class Minute < Tick
+      FREQ = 'M'.freeze
+
+      def multiplier
+        1.to_r / 24 / 60
+      end
+    end
+
+    # Create an hours offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Hour offset
+    #   offset = DaruLite::Offsets::Hour.new(8)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2012-05-01T12:03:00+00:00 ((2456049j,43380s,0n),+0s,2299161j)>
+    class Hour < Tick
+      FREQ = 'H'.freeze
+
+      def multiplier
+        1.to_r / 24
+      end
+    end
+
+    # Create an days offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Day offset
+    #   offset = DaruLite::Offsets::Day.new(2)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2012-05-03T04:03:00+00:00 ((2456051j,14580s,0n),+0s,2299161j)>
+    class Day < Tick
+      FREQ = 'D'.freeze
+
+      def multiplier
+        1
+      end
+    end
+
+    # Create an months offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Month offset
+    #   offset = DaruLite::Offsets::Month.new(5)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2012-10-01T04:03:00+00:00 ((2456202j,14580s,0n),+0s,2299161j)>
+    class Month < Tick
+      FREQ = 'MONTH'.freeze
+
+      def +(other)
+        other >> @n
+      end
+
+      def -(other)
+        other << @n
+      end
+    end
+
+    # Create a years offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a Year offset
+    #   offset = DaruLite::Offsets::Year.new(2)
+    #   offset + DateTime.new(2012,5,1,4,3)
+    #   #=> #<DateTime: 2014-05-01T04:03:00+00:00 ((2456779j,14580s,0n),+0s,2299161j)>
+    class Year < Tick
+      FREQ = 'YEAR'.freeze
+
+      def +(other)
+        other >> (@n * 12)
+      end
+
+      def -(other)
+        other << (@n * 12)
+      end
+    end
+
+    class Week < DateOffset
+      def initialize(*args)
+        @n = args[0].is_a?(Hash) ? 1 : args[0]
+        opts = args[-1]
+        @weekday = opts[:weekday] || 0
+      end
+
+      def +(other)
+        wday = other.wday
+        distance = (@weekday - wday).abs
+        if @weekday > wday
+          other + distance + (7 * (@n - 1))
+        else
+          other + (7 - distance) + (7 * (@n - 1))
+        end
+      end
+
+      def -(other)
+        wday = other.wday
+        distance = (@weekday - wday).abs
+        if @weekday >= wday
+          other - ((7 - distance) + (7 * (@n - 1)))
+        else
+          other - (distance + (7 * (@n - 1)))
+        end
+      end
+
+      def on_offset?(date_time)
+        date_time.wday == @weekday
+      end
+
+      def freq_string
+        "#{@n == 1 ? '' : @n.to_s}W-#{DaruLite::DAYS_OF_WEEK.key(@weekday)}"
+      end
+    end
+
+    # Create a month begin offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a MonthBegin offset
+    #   offset = DaruLite::Offsets::MonthBegin.new(2)
+    #   offset + DateTime.new(2012,5,5)
+    #   #=> #<DateTime: 2012-07-01T00:00:00+00:00 ((2456110j,0s,0n),+0s,2299161j)>
+    class MonthBegin < DateOffsetType
+      FREQ = 'MB'.freeze
+
+      def +(other)
+        @n.times do
+          days_in_month = DaruLite::MONTH_DAYS[other.month]
+          days_in_month += 1 if other.leap? && other.month == 2
+          other += (days_in_month - other.day + 1)
+        end
+
+        other
+      end
+
+      def -(other)
+        @n.times do
+          other <<= 1 if on_offset?(other)
+          other = DateTime.new(other.year, other.month, 1,
+                               other.hour, other.min, other.sec)
+        end
+
+        other
+      end
+
+      def on_offset?(date_time)
+        date_time.day == 1
+      end
+    end
+
+    # Create a month end offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a MonthEnd offset
+    #   offset = DaruLite::Offsets::MonthEnd.new
+    #   offset + DateTime.new(2012,5,5)
+    #   #=> #<DateTime: 2012-05-31T00:00:00+00:00 ((2456079j,0s,0n),+0s,2299161j)>
+    class MonthEnd < DateOffsetType
+      FREQ = 'ME'.freeze
+
+      def +(other)
+        @n.times do
+          other >>= 1 if on_offset?(other)
+          days_in_month = DaruLite::MONTH_DAYS[other.month]
+          days_in_month += 1 if other.leap? && other.month == 2
+
+          other += (days_in_month - other.day)
+        end
+
+        other
+      end
+
+      def -(other)
+        @n.times do
+          other <<= 1
+          days_in_month = DaruLite::MONTH_DAYS[other.month]
+          days_in_month += 1 if other.leap? && other.month == 2
+
+          other += (days_in_month - other.day)
+        end
+
+        other
+      end
+
+      def on_offset?(date_time)
+        (date_time + 1).day == 1
+      end
+    end
+
+    # Create a year begin offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a YearBegin offset
+    #   offset = DaruLite::Offsets::YearBegin.new(3)
+    #   offset + DateTime.new(2012,5,5)
+    #   #=> #<DateTime: 2015-01-01T00:00:00+00:00 ((2457024j,0s,0n),+0s,2299161j)>
+    class YearBegin < DateOffsetType
+      FREQ = 'YB'.freeze
+
+      def +(other)
+        DateTime.new(other.year + @n, 1, 1,
+                     other.hour, other.min, other.sec)
+      end
+
+      def -(other)
+        if on_offset?(other)
+          DateTime.new(other.year - @n, 1, 1,
+                       other.hour, other.min, other.sec)
+        else
+          DateTime.new(other.year - (@n - 1), 1, 1)
+        end
+      end
+
+      def on_offset?(date_time)
+        date_time.month == 1 && date_time.day == 1
+      end
+    end
+
+    # Create a year end offset
+    #
+    # @param n [Integer] The number of times an offset should be applied.
+    # @example Create a YearEnd offset
+    #   offset = DaruLite::Offsets::YearEnd.new
+    #   offset + DateTime.new(2012,5,5)
+    #   #=> #<DateTime: 2012-12-31T00:00:00+00:00 ((2456293j,0s,0n),+0s,2299161j)>
+    class YearEnd < DateOffsetType
+      FREQ = 'YE'.freeze
+
+      def +(other)
+        if on_offset?(other)
+          DateTime.new(other.year + @n, 12, 31,
+                       other.hour, other.min, other.sec)
+        else
+          DateTime.new(other.year + (@n - 1), 12, 31,
+                       other.hour, other.min, other.sec)
+        end
+      end
+
+      def -(other)
+        DateTime.new(other.year - 1, 12, 31)
+      end
+
+      def on_offset?(date_time)
+        date_time.month == 12 && date_time.day == 31
+      end
+    end
+
+    LIST = {
+      secs: Second,
+      mins: Minute,
+      hours: Hour,
+      days: Day,
+      months: Month,
+      years: Year
+    }.freeze
+  end
+end

data/lib/daru_lite/exceptions.rb

@@ -0,0 +1,2 @@
+class SizeError < StandardError
+end

data/lib/daru_lite/extensions/which_dsl.rb

@@ -0,0 +1,53 @@
+# Support for a simple query DSL for accessing where(), inspired by gem "squeel"
+
+module DaruLite
+  class DataFrame
+    # a simple query DSL for accessing where(), inspired by gem "squeel"
+    # e.g.:
+    # df.which{ `FamilySize` == `FamilySize`.max }
+    # equals
+    # df.where( df['FamilySize'].eq( df['FamilySize'].max ) )
+    #
+    # e.g.:
+    # df.which{ (`NameTitle` == 'Dr') & (`Sex` == 'female') }
+    # equals
+    # df.where( df['NameTitle'].eq('Dr') & df['Sex'].eq('female') )
+    def which(&block)
+      WhichQuery.new(self, &block).exec
+    end
+  end
+
+  class WhichQuery
+    def initialize(df, &condition)
+      @df = df
+      @condition = condition
+    end
+
+    # executes a block of DSL code
+    def exec
+      query = instance_eval(&@condition)
+      @df.where(query)
+    end
+
+    def `(vector_name)
+      vector_name = vector_name.to_sym if !@df.has_vector?(vector_name) && @df.has_vector?(vector_name.to_sym)
+      VectorWrapper.new(@df[vector_name])
+    end
+
+    class VectorWrapper < SimpleDelegator
+      {
+        :== => :eq,
+        :!= => :not_eq,
+        :< => :lt,
+        :<= => :lteq,
+        :> => :mt,
+        :>= => :mteq,
+        :=~ => :in
+      }.each do |opt, method|
+        define_method opt do |*args|
+          send(method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/daru_lite/formatters/table.rb

@@ -0,0 +1,52 @@
+module DaruLite
+  module Formatters
+    class Table
+      def self.format(data, options = {})
+        new(data, options[:headers], options[:row_headers])
+          .format(options[:threshold], options[:spacing])
+      end
+
+      def initialize(data, headers, row_headers)
+        @data = data || []
+        @headers = (headers || []).to_a
+        @row_headers = (row_headers || []).to_a
+        @row_headers = [''] * @data.to_a.size if @row_headers.empty?
+      end
+
+      def format(threshold = nil, spacing = nil)
+        rows = build_rows(threshold || DaruLite.max_rows)
+
+        formatter = construct_formatter rows, spacing || DaruLite.spacing
+
+        rows.map { |r| formatter % r }.join("\n")
+      end
+
+      private
+
+      def build_rows(threshold)
+        @row_headers.first(threshold).zip(@data).map do |(r, datarow)|
+          [*[r].flatten.map(&:to_s), *(datarow || []).map { |v| pretty_to_s(v) }]
+        end.tap do |rows|
+          unless @headers.empty?
+            spaces_to_add = rows.empty? ? 0 : rows.first.size - @headers.size
+            rows.unshift ([''] * spaces_to_add) + @headers.map(&:to_s)
+          end
+
+          rows << (['...'] * rows.first.count) if @row_headers.count > threshold
+        end
+      end
+
+      def construct_formatter(rows, spacing)
+        width = rows.flatten.map(&:size).max || 0
+        width = [3, width].max # not less than 'nil'
+        width = [width, spacing].min # not more than max width
+
+        " %#{width}.#{width}s" * rows.first.size if rows.first
+      end
+
+      def pretty_to_s(val)
+        val.nil? ? 'nil' : val.to_s
+      end
+    end
+  end
+end

data/lib/daru_lite/helpers/array.rb

@@ -0,0 +1,53 @@
+module DaruLite
+  module ArrayHelper
+    module_function
+
+    # Recode repeated values on an array, adding the number of repetition
+    # at the end
+    # Example:
+    #   a=%w{a b c c d d d e}
+    #   a.recode_repeated
+    #   => ["a","b","c_1","c_2","d_1","d_2","d_3","e"]
+    def recode_repeated(array)
+      return array if array.size == array.uniq.size
+
+      # create hash of { <name> => 0}
+      # for all names which are more than one time in array
+      counter = array
+                .group_by(&:itself)
+                .select { |_, g| g.size > 1 }
+                .keys
+                .to_h { |n| [n, 0] }
+
+      # ...and use this hash for actual recode
+      array.collect do |n|
+        if counter.key?(n)
+          counter[n] += 1
+          new_n = format('%<index>s_%<counter>d', index: n, counter: counter[n])
+          n.is_a?(Symbol) ? new_n.to_sym : new_n
+        else
+          n
+        end
+      end
+    end
+
+    def array_of?(array, match)
+      array.is_a?(Array) &&
+        !array.empty? &&
+        array.all? { |el| match === el } # rubocop:disable Style/CaseEquality,Performance/RedundantEqualityComparisonBlock
+    end
+
+    def sort_composite_data(array)
+      array.sort
+    rescue ArgumentError, TypeError => e
+      case e.to_s
+      when /comparison of Symbol with String failed/,
+        /comparison of Symbol with \d+ failed/,
+        /comparison of String with :.* failed/,
+        /comparison of Integer with :.* failed/,
+        /no implicit conversion from nil to integer/
+        array.sort_by(&:to_s)
+      end
+    end
+  end
+end