cotcube-helpers 0.1.4 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5e22624f57015916268dc4ca26ec98e2d759150ab9dc88dc3b5ceda93248148
-  data.tar.gz: 73628320f993e73c83423dded2880f44412174c8d1cd4dd201ace3f2c6c6e41e
+  metadata.gz: 91263c1bbd453c5b1e6c8a3cfe7c0dee3542f5873e82d15caf8118b6b20ce603
+  data.tar.gz: f886c9fe330f439b61c0aee1f3c9cc55b3df161511968c25bb92df5cb85c2f0c
 SHA512:
-  metadata.gz: 4b7b9051f22418e8a5a17245b1a410e284bf279787f1f9d279f58083f93a588c916926badc2b2834361241d874126a3af11c36805d20afe5b34049934c16cb6b
-  data.tar.gz: fd0dbfb22b5b7631c5ee220de6551e1adfe9a38311afe85918598fdf86d9dd50e1028663b633c8a675853238767455504bdfa9163a466ef3e362950aa44cf064
+  metadata.gz: '00591395a0289380b4063ffa6766073d7619d1f7cc0576afb722854cbdc97f03d5bd651feaaf6a5f49de61770f6d16982a3ae7de26a9fd030c40efec6198e9f5'
+  data.tar.gz: c25f08c4677106ec7dc714653830bb6f9ef668f70df50343c443f0d0c79dccd110bf425fe7fa8cdc28b7ecf18db2d3aafd7cccd5f00b2bb5f3a8113fc17f65fa

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.1.7 (January 17, 2021)
+  - added new method 'simple_series_stats'
+
+## 0.1.6 (January 15, 2021)
+  - removing :ranges from Range#select_within
+  - Added Array#select_right_by
+
+## 0.1.5.4 (January 02, 2021)
+
+
+## 1.5.1.3 (January 02, 2021)
+  - hotfixing the hotfix (hello CI tools, c ya coming)
+
+## 1.5.1.2 (January 02, 2021)
+  - hotfix problem in Range.to_time_intervals
+
+## 0.1.5.1 (January 02, 2021)
+  - Hotfixing parallelize
+
+## 0.1.5 (January 02, 2021)
+  - applied new datetime helper to Range#to_time_intervals
+  - added new DateTime extension, containing 'to_seconds_since_sunday_morning'
+  - added #select_within to array_ext
+
 ## 0.1.4 (December 27, 2020)
   - applied cops
   - added README for reduce; minor changes

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.7

data/lib/cotcube-helpers.rb

@@ -12,6 +12,7 @@ require_relative 'cotcube-helpers/enum_ext'
 require_relative 'cotcube-helpers/hash_ext'
 require_relative 'cotcube-helpers/range_ext'
 require_relative 'cotcube-helpers/string_ext'
+require_relative 'cotcube-helpers/datetime_ext'
 require_relative 'cotcube-helpers/subpattern'
 require_relative 'cotcube-helpers/parallelize'
 require_relative 'cotcube-helpers/simple_output'

data/lib/cotcube-helpers/array_ext.rb

@@ -53,4 +53,45 @@ class Array
       block.call(self[i - 2], self[i - 1], self[i])
     end.compact
   end
+
+  # selects all elements from array that fit in given ranges.
+  # if :attr is given, selects all elements, where elem[:attr] fit
+  # raises if elem.first[attr].nil?
+  def select_within(ranges:, attr: nil, &block)
+    unless attr.nil? || first[attr]
+      raise ArgumentError,
+            "At least first element of Array '#{first}' does not contain attr '#{attr}'!"
+    end
+    raise ArgumentError, 'Ranges should be an Array or, more precisely, respond_to :map' unless ranges.respond_to? :map
+    raise ArgumentError, 'Each range in :ranges should respond to .include!' unless ranges.map do |x|
+                                                                                      x.respond_to? :include?
+                                                                                    end.reduce(:&)
+
+    select do |el|
+      value = attr.nil? ? el : el[attr]
+      ranges.map do |range|
+        range.include?(block.nil? ? value : block.call(value))
+      end.reduce(:|)
+    end
+  end
+
+  def select_right_by(inclusive: false, exclusive: false, initial: [], &block)
+    # unless range.is_a? Range and
+    #       (range.begin.nil? or range.begin.is_a?(Integer)) and
+    #       (range.end.nil? or range.end.is_a?(Integer))
+    #  raise ArgumentError, ":range, if given, must be a range of ( nil|Integer..nil|Integer), got '#{range}'"
+    # end
+
+    raise ArgumentError, 'No block given.' unless block.is_a? Proc
+
+    inclusive = true unless exclusive
+    if inclusive && exclusive
+      raise ArgumentError,
+            "Either :inclusive or :exclusive must remain falsey, got '#{inclusive}' and '#{exclusive}'"
+    end
+
+    index = find_index { |obj| block.call(obj) }
+
+    self[((inclusive ? index : index + 1)..)]
+  end
 end

data/lib/cotcube-helpers/datetime_ext.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Monkey patching the Ruby class DateTime
+class DateTime
+  # based on the fact that sunday is 'wday 0' plus that trading week starts
+  #   sunday 0:00 (as trading starts sunday 5pm CT to fit tokyo monday morning)
+  def to_seconds_since_sunday_morning
+    wday * 86_400 + hour * 3600 + min * 60 + sec
+  end
+
+  alias to_sssm to_seconds_since_sunday_morning
+end

data/lib/cotcube-helpers/parallelize.rb

@@ -7,9 +7,9 @@ module Cotcube
     def parallelize(ary, processes: 1, threads: 1, progress: '', &block)
       chunks = []
       if [0, 1].include? processes
-        result = Parallel.map(ary, in_threads: threads) { |u, &in_thread| in_thread.call(u) }
-      elsif [0, 1].include?(threads)
-        result = Parallel.map(ary, in_processes: processes) { |u, &in_process| in_process.call(u) }
+        result = Parallel.map(ary, in_threads: threads, &block)
+      elsif [0, 1].include? threads
+        result = Parallel.map(ary, in_processes: processes, &block)
       else
         ary.each_slice(threads) { |chunk| chunks << chunk }
         result = if progress == ''

data/lib/cotcube-helpers/range_ext.rb

@@ -2,11 +2,17 @@
 
 # Monkey patching the Ruby Core class Range
 class Range
-  def to_time_intervals(step:, timezone: Time.find_zone('America/Chicago'), ranges: nil)
+  def to_time_intervals(step:,
+                        timezone: Time.find_zone('America/Chicago'),
+                        # ranges: nil,
+                        debug: false)
     unless step.is_a? ActiveSupport::Duration
       raise ArgumentError,
             ":step must be a 'ActiveSupport::Duration', like '15.minutes', but '#{step}' is a '#{step.class}'"
     end
+    unless [15.minutes, 60.minutes, 1.hour, 1.day].include? step
+      raise ArgumentError, 'Sorry, currently supporting only 15.minutes, 1.hour, 1.day as :step'
+    end
 
     valid_classes = [ActiveSupport::TimeWithZone, Time, Date, DateTime]
     unless timezone.is_a? ActiveSupport::TimeZone
@@ -26,64 +32,65 @@ class Range
             ":self.end seems not to be proper time value: #{ending} is a #{ending.class}"
     end
 
-    ##### The following is the actual big magic line, as it creates the raw target array:
-    #
-    result = (starting.to_time.to_i..ending.to_time.to_i).step(step).to_a.map { |x| timezone.at(x) }
-    #
-    # ###################<3##
+    # here sub-day and super-day need to be distinguished, as they react differently to daylight time
+    # for super-day, just return an array containing all calendar days
+    if step.to_i >= 1.day
+      (starting.to_date..ending.to_date).to_a.map(&:to_datetime)
+    else
 
-    # with step.to_i >= 86400 we are risking stuff like 25.hours to return bogus
-    # also notice: When using this with swaps, you will loose 1 hour (#f**k_it)
-    #
-    # eventually, for dailies and above, return M-F default, return S-S when forced by empty ranges
-    if step.to_i >= 86_400
-      return result.select do |x|
-               (not ranges.nil?) && ranges.empty? ? true : (not [6, 0].include?(x.wday))
-             end
-    end
+      # sub-day is checked for DST
+      # noinspection RubyNilAnalysis
+      actual_starting   = starting.to_time.to_i
+      actual_ending     = ending.to_time.to_i
+      actual_ending -= 3600 if starting.dst? && (not ending.dst?)
+      actual_ending += 3600 if ending.dst? && (not starting.dst?)
 
-    # sub-day is checked for DST and filtered along provided ranges
-    starting_with_dst = result.first.dst?
+      ##### The following is the actual big magic line, as it creates the raw target array:
+      #
+      result = (actual_starting..actual_ending).step(step).to_a.map { |x| timezone.at(x) }
+      #
+      # ###################<3##
 
-    # The following lambda is completely misplaces here.
-    # It should probably relocated to Cotcube::Bardata
-    # NOTE: In this current version 12 belongs to it succeeding hour
-    #       i.e. 12am is right before 1am and 12pm right before 1pm
-    convert_to_sec_since = lambda do |clocking|
-      from_src, to_src = clocking.split(' - ')
-      regex = /^(?<hour>\d+):(?<minute>\d+)(?<morning>[pa]).?m.*/
+      # It should probably relocated to Cotcube::Bardata
+      # NOTE: In this current version 12 belongs to it succeeding hour
+      #       i.e. 12am is right before 1am and 12pm right before 1pm
+      convert_to_sec_since = lambda do |clocking|
+        from_src, to_src = clocking.split(' - ')
+        regex = /^(?<hour>\d+):(?<minute>\d+)(?<morning>[pa]).?m.*/
 
-      from = from_src.match(regex)
-      to   = to_src.match(regex)
+        from = from_src.match(regex)
+        to   = to_src.match(regex)
 
-      from_i = from[:hour].to_i * 3600 + from[:minute].to_i * 60 + (from[:morning] == 'a' ? 2 : 1) * 12 * 3600
-      to_i = to[:hour].to_i * 3600 + to[:minute].to_i * 60 + (to[:morning] == 'a' ? 2 : 3) * 12 * 3600
+        from_i = from[:hour].to_i * 3600 + from[:minute].to_i * 60 + (from[:morning] == 'a' ? 2 : 1) * 12 * 3600
+        to_i = to[:hour].to_i * 3600 + to[:minute].to_i * 60 + (to[:morning] == 'a' ? 2 : 3) * 12 * 3600
 
-      (0...5).to_a.map { |i| [from_i + i * 24 * 3600, to_i + i * 24 * 3600] }
-    end
-    convert_to_sec_since.call('9:00a.m - 5:00p.m.')
+        (0...5).to_a.map { |i| [from_i + i * 24 * 3600, to_i + i * 24 * 3600] }
+      end
+      convert_to_sec_since.call('9:00a.m - 5:00p.m.')
 
-    seconds_since_sunday_morning = ->(x) { x.wday * 86_400 + x.hour * 3600 + x.min * 60 + x.sec }
-    ranges ||= [
-      61_200...144_000,   # Sun 5pm .. Mon 4pm
-      147_600...230_400,  # Mon 5pm .. Tue 4pm
-      234_000...316_800,  # ...
-      320_400...403_200,
-      406_800...489_600
-    ]
+      # ranges ||= [
+      #  61_200...144_000,   # Sun 5pm .. Mon 4pm
+      #  147_600...230_400,  # Mon 5pm .. Tue 4pm
+      #  234_000...316_800,  # ...
+      #  320_400...403_200,
+      #  406_800...489_600
+      # ]
 
-    # if there was a change towards daylight saving time, subtract 1 hour, otherwise add 1 hour
-    result.map! do |time|
-      if (not starting_with_dst) && time.dst?
-        time - 3600
-      elsif starting_with_dst && (not time.dst?)
-        time + 3600
-      else
+      # if there was a change towards daylight saving time, subtract 1 hour, otherwise add 1 hour
+      result.map! do |time|
+        print "#{time}\t" if debug
+        if (not starting.dst?) && time.dst?
+          time -= 3600
+          print "Time reduced (not starting_DST, but current\t" if debug
+        elsif starting.dst? && (not time.dst?)
+          time += 3600
+          print "Time extended (starting DST, but not current\t" if debug
+        end
+        puts "#{time} " if debug
         time
       end
-    end
-    return result if ranges.empty?
 
-    result.select { |x| ranges.map { |r| r.include? seconds_since_sunday_morning.call(x) }.reduce(:|) }
+      result # .select_within(ranges: ranges) { |x| x.to_datetime.to_seconds_since_sunday_morning }
+    end
   end
 end

data/lib/cotcube-helpers/simple_series_stats.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Cotcube
+  # Missing top level documentation
+  module Helpers
+    # if given a block, :ind of base is set by block.call()
+    # dim reduces the sample size by top n% and least n%, so dim of 0.5 would remove 100% of the sample
+    def simple_series_stats(base:, ind: nil, dim: 0, format: '%5.2f', print: true, &block)
+      raise ArgumentError, 'Need :ind of type integer' if base.first.is_a?(Array) and not ind.is_a?(Integer)
+      raise ArgumentError, 'Need :ind to evaluate base' if base.first.is_a?(Hash) and ind.nil?
+
+      dim = dim.to_f if dim.is_a? Numeric
+      dim = 0 if dim==false
+
+      raise ArgumentError, 'Expecting 0 <= :dim < 0.5' unless dim.is_a?(Float) and dim >= 0  and dim < 0.5
+      raise ArgumentError, 'Expecting arity of one if block given' if block_given? and not block.arity==1
+
+      precision = format[-1] == 'f' ? format[..-2].split('.').last.to_i : 0
+      worker = base.
+        tap {|b| b.map{|x| x[ind] = block.call(x) } if block.is_a? Proc }.
+        map {|x| ind.nil? ? x : x[ind] }.
+        compact.
+        sort
+      unless dim.zero?
+        reductor = (base.size * dim).round
+        puts reductor
+        worker = worker[reductor..base.size - reductor]
+        puts worker.size
+      end
+      result = {}
+
+      result[:size]   =  worker.size
+      result[:min]    =  worker.first
+      result[:avg]    = (worker.reduce(:+) / result[:size]).round(precision+1)
+      result[:lower]  =  worker[ (result[:size] * 1 / 4).round ]
+      result[:median] =  worker[ (result[:size] * 2 / 4).round ]
+      result[:upper]  =  worker[ (result[:size] * 3 / 4).round ]
+      result[:max]    =  worker.last
+
+      result[:output] = result.
+        reject{|k,_| k == :size}.
+        map{|k,v| { type: k, value: v, output: "#{k}: #{format(format, v)}".colorize(k==:avg ? :light_yellow : :white) } }.
+        sort_by{|x| x[:value]}.
+        map{|x| x[:output]}
+      output = "[" + 
+               " size: #{format '%6d', result[:size]} | ".light_white + 
+               output.join(' |  ') + 
+               " ]"
+
+      puts result[:output] if print
+      result
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.7
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-27 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -82,6 +82,7 @@ files:
 - cotcube-helpers.gemspec
 - lib/cotcube-helpers.rb
 - lib/cotcube-helpers/array_ext.rb
+- lib/cotcube-helpers/datetime_ext.rb
 - lib/cotcube-helpers/enum_ext.rb
 - lib/cotcube-helpers/hash_ext.rb
 - lib/cotcube-helpers/input.rb
@@ -89,6 +90,7 @@ files:
 - lib/cotcube-helpers/range_ext.rb
 - lib/cotcube-helpers/reduce.rb
 - lib/cotcube-helpers/simple_output.rb
+- lib/cotcube-helpers/simple_series_stats.rb
 - lib/cotcube-helpers/string_ext.rb
 - lib/cotcube-helpers/subpattern.rb
 - lib/cotcube-helpers/swig/date.rb