cotcube-helpers 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 819dae89b6428b3cec4226d40f4afa3b790108b2e7a0f8ff9784b49532a894e9
+  data.tar.gz: 2e4823aa3a4f86efa8d94ff07be306cb991a7bd08504cae0209025127e67d472
+SHA512:
+  metadata.gz: 46647ed87173997191a22b05072e0ce4b53bba9be4a222d86a92605bf35d9c3d4d33ed0381c6ab3e46106e21851d10f4b9b3b178136bf780bdcf89ce055cc469
+  data.tar.gz: 7acdf173d676c7db61e6e2a1aa3111b22ae00c55768611d7355b4f13216c225f9e5ef9204a23796694b95d21d955e7a53e72d3b62b390e3735786aceb0b67801

data/.irbrc.rb

@@ -0,0 +1,12 @@
+def verbose_toggle
+  irb_context.echo ? irb_context.echo = false : irb_context.echo = true
+end
+
+alias vt verbose_toggle
+
+$debug = true
+IRB.conf[:USE_MULTILINE] = false
+# require 'bundler'
+# Bundler.require
+
+require_relative 'lib/cotcube-helpers'

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.1 (December 21, 2020)
+
+

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in bitangent.gemspec
+gemspec
+

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/cotcube-helpers.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cotcube-helpers'
+  spec.version       = File.read("#{__dir__}/VERSION")
+  spec.authors       = ['Benjamin L. Tischendorf']
+  spec.email         = ['donkeybridge@jtown.eu']
+
+  spec.summary       = 'Some helpers and core extensions as part of the Cotcube Suite.'
+  spec.description   = 'Some helpers and core extensions as part of the Cotcube Suite...'
+
+  spec.homepage      = 'https://github.com/donkeybridge/'+ spec.name
+  spec.license       = 'BSD-4-Clause'
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.7')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = spec.homepage + '/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~>3.6'
+  spec.add_development_dependency 'yard', '~>0.9'
+end

data/lib/cotcube-helpers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext/time'
+require 'active_support/core_ext/numeric'
+require 'parallel'
+
+require_relative 'cotcube-helpers/array_ext'
+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/subpattern.rb'
+require_relative 'cotcube-helpers/parallelize'
+require_relative 'cotcube-helpers/simple_output'
+require_relative 'cotcube-helpers/input'
+
+
+module Cotcube
+  module Helpers
+
+    module_function :sub, 
+      :parallelize,
+      :keystroke
+
+
+    
+    # please not that module_functions of source provided in private files must be published there
+  end
+end
+

data/lib/cotcube-helpers/array_ext.rb

@@ -0,0 +1,53 @@
+class Array
+
+  # returns nil if the compacted array is empty, otherwise returns the compacted array
+  def compact_or_nil(*args, &block)
+    return nil if self.compact == [] 
+    yield self.compact
+  end
+
+  # sorts by a given attribute and then returns groups of where this attribute is equal
+  # .... seems like some_array.group_by(&attr).values
+  def split_by(attrib)
+    res = []
+    sub = [] 
+    self.sort_by(&attrib).each do |elem|
+      if sub.empty? or sub.last[attrib] == elem[attrib]
+        sub << elem
+      else
+        res << sub
+        sub = [ elem ]
+      end
+    end
+    res << sub
+    res
+  end
+
+  # This method iterates over an Array by calling the given block on all 2 consecutive elements
+  # it returns a Array of self.size - 1
+  #
+  def pairwise(&block)
+    raise ArgumentError, 'Array.one_by_one needs an arity of 2 (i.e. |a, b|)' unless block.arity == 2
+    return [] if size <= 1
+
+    each_with_index.map do |_, i|
+      next if i.zero?
+
+      block.call(self[i - 1], self[i])
+    end.compact
+  end
+
+  alias_method :one_by_one, :pairwise
+
+  # same as pairwise, but with arity of three
+  def triplewise(&block)
+    raise ArgumentError, 'Array.triplewise needs an arity of 3 (i.e. |a, b, c|)' unless block.arity == 3
+    return [] if size <= 2
+
+    each_with_index.map do |_, i|
+      next if i < 2
+
+      block.call(self[i - 2], self[i-1], self[i])
+    end.compact
+  end
+end

data/lib/cotcube-helpers/enum_ext.rb

@@ -0,0 +1,11 @@
+class Enumerator
+  def shy_peek
+    begin
+      ret = self.peek
+    rescue
+      ret = nil
+    end
+    ret
+  end
+end
+

data/lib/cotcube-helpers/hash_ext.rb

@@ -0,0 +1,15 @@
+class Hash
+
+  def keys_to_sym
+    self.keys.each do |key| 
+      case self[key].class.to_s
+      when "Hash"
+        self[key].keys_to_sym
+      when "Array"
+        self[key].map {|el| el.is_a?(Hash) ? el.keys_to_sym : el}
+      end
+      self[key.to_sym] = self.delete(key)
+    end
+    self
+  end
+end

data/lib/cotcube-helpers/input.rb

@@ -0,0 +1,44 @@
+module Cotcube
+  module Helpers
+    def keystroke(quit: false)
+      begin
+        # save previous state of stty
+        old_state = `stty -g`
+        # disable echoing and enable raw (not having to press enter)
+        system "stty raw -echo"
+        c = STDIN.getc.chr
+        # gather next two characters of special keys
+        if(c=="\e")
+          extra_thread = Thread.new{
+            c = c + STDIN.getc.chr
+            c = c + STDIN.getc.chr
+          }
+          # wait just long enough for special keys to get swallowed
+          extra_thread.join(0.00001)
+          # kill thread so not-so-long special keys don't wait on getc
+          extra_thread.kill
+        end
+      rescue => ex
+        puts "#{ex.class}: #{ex.message}"
+        puts ex.backtrace
+      ensure
+        # restore previous state of stty
+        system "stty #{old_state}"
+      end
+      c.each_byte do |x| 
+        case x
+        when 3
+          puts "Strg-C captured, exiting..."
+          quit ? exit : (return true)
+        when 13
+          return "_return_"
+        when 27
+          puts "ESCAPE gathered"
+          return "_esc_"
+        else
+          return c
+        end
+      end
+    end
+  end
+end

data/lib/cotcube-helpers/parallelize.rb

@@ -0,0 +1,33 @@
+module Cotcube
+  module Helpers
+
+    def parallelize(ary, opts = {}, &block)
+      processes =           opts[:processes].nil? ? 1  : opts[:processes]
+      threads_per_process = opts[:threads  ].nil? ? 1  : opts[:threads]
+      progress =            opts[:progress ].nil? ? "" : opts[:progress]
+      chunks = [] 
+      if processes == 0 or processes == 1
+        r = Parallel.map(ary, in_threads: threads_per_process) {|u| v = yield(u); v}
+      elsif [0,1].include?(threads_per_process)
+        r = Parallel.map(ary, in_processes: processes) {|u| v = yield(u)}
+      else
+        ary.each_slice(threads_per_process) {|chunk| chunks << chunk }
+        if progress == "" 
+          r = Parallel.map(chunks, :in_processes => processes) do |chunk|
+            Parallel.map(chunk, in_threads: threads_per_process) do |unit|
+              yield(unit) 
+            end
+          end
+        else
+          r = Parallel.map(ary, :progress => progress, :in_processes => processes) do |chunk|
+            Parallel.map(chunk, in_threads: threads_per_process) do |unit|
+              yield(unit)
+            end
+          end
+        end
+      end
+      return r
+    end
+
+  end
+end

data/lib/cotcube-helpers/range_ext.rb

@@ -0,0 +1,52 @@
+class Range
+  def to_time_intervals(timezone: Time.find_zone('America/Chicago'), step:, ranges: nil)
+
+    raise ArgumentError, ":step must be a 'ActiveSupport::Duration', like '15.minutes', but '#{step}' is a '#{step.class}'" unless step.is_a? ActiveSupport::Duration
+
+    valid_classes = [ ActiveSupport::TimeWithZone, Time, Date, DateTime ]
+    raise "Expecting 'ActiveSupport::TimeZone' for :timezone, got '#{timezone.class}" unless timezone.is_a? ActiveSupport::TimeZone
+    starting = self.begin
+    ending   = self.end
+    starting = timezone.parse(starting) if starting.is_a? String
+    ending   = timezone.parse(ending)   if ending.is_a?   String
+    raise ArgumentError, ":self.begin seems not to be proper time value: #{starting} is a #{starting.class}" unless valid_classes.include? starting.class
+    raise ArgumentError, ":self.end seems not to be proper time value: #{ending} is a #{ending.class}" unless valid_classes.include? ending.class
+
+    ##### The following is the actual big magic line: 
+    # 
+    result    = (starting.to_time.to_i..ending.to_time.to_i).step(step).to_a.map{|x| timezone.at(x)}
+    #
+    ####################<3
+
+
+    # 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
+    return result.select{|x| (not ranges.nil? and ranges.empty?) ? true : (not [6,0].include?(x.wday)) } if step.to_i >= 86400
+
+    # sub-day is checked for DST and filtered along provided ranges
+    starting_with_dst = result.first.dst?
+    seconds_since_sunday_morning = lambda {|x| x.wday * 86400 + x.hour * 3600 + x.min * 60 + x.sec}
+    ranges ||= [
+      61200..143999,  
+      147600..230399,
+      234000..316799,
+      320400..403199,
+      406800..489599
+    ]
+
+    # if there was a change towards daylight saving time, substract 1 hour, otherwise add 1 hour
+    result.map! do |time|
+      if    not starting_with_dst and     time.dst?
+	time - 3600
+      elsif     starting_with_dst and not time.dst?
+	time + 3600
+      else
+	time
+      end
+    end
+    return result if ranges.empty? 
+    result.select{|x| ranges.map{|r| r.include? seconds_since_sunday_morning.call(x)}.reduce(:|) }
+  end
+end

data/lib/cotcube-helpers/simple_output.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Helpers
+    # SimpleOutput is a very basic outputhandler, which is actually only there to mock output handling until
+    #   a more sophisticated solution is available (e.g. OutPutHandler gem is reworked and tested )
+    class SimpleOutput
+      # Aliasing puts and print, as they are included / inherited (?) from IO
+      alias_method :superputs,  :puts # rubocop:disable Style/Alias
+      # Aliasing puts and print, as they are included / inherited (?) from IO
+      alias_method :superprint, :print # rubocop:disable Style/Alias
+
+      # ...
+      def puts(msg)
+        superputs msg
+      end
+
+      # ...
+      def print(msg)
+        superprint msg
+      end
+
+      # The source expects methods with exclamation mark (for unbuffered output) -- although it makes no sense
+      #   here, we need to provide the syntax for later.
+      alias puts!  puts
+      alias print! print
+    end
+  end
+end

data/lib/cotcube-helpers/string_ext.rb

@@ -0,0 +1,9 @@
+class String
+  def is_valid_json?
+     JSON.parse(self)
+     return true
+  rescue JSON::ParserError => e
+     return false
+  end
+end
+

data/lib/cotcube-helpers/subpattern.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Helpers
+    # sub (should be 'subpattern', but too long) is for use in case / when statements
+    #   it returns a lambda, that checks the case'd expression for matching subpattern
+    #   based on the the giving minimum. E.g. 'a', 'ab' .. 'abcd' will match sub(1){'abcd'}
+    #   but only 'abc' and 'abcd' will match sub(3){'abcd'}
+    #
+    #   The recommended use within evaluating user input, where abbreviation of incoming commands
+    #   is desirable (h for hoover and hyper, what will translate to sub(2){'hoover'} and sub(2){hyper})
+    #
+    #   To extend functionality even more, it is possible to send a group of patterns to, like
+    #   sub(2){[:hyper,:mega]}, what will respond truthy to "hy" and "meg" but not to "m" or "hypo"
+    def sub(minimum = 1)
+      pattern = yield
+      case pattern
+      when String, Symbol, NilClass
+        pattern = pattern.to_s
+        lambda do |x|
+          return false if x.nil? || (x.size < minimum)
+
+          return ((pattern =~ /^#{x}/i).nil? ? false : true)
+        end
+      when Array
+        pattern.map do |x|
+          unless [String, Symbol, NilClass].include? x.class
+            raise TypeError, "Unsupported class '#{x.class}' for '#{x}'in pattern '#{pattern}'."
+          end
+        end
+        lambda do |x|
+          pattern.each do |sub|
+            sub = sub.to_s
+            return false if x.size < minimum
+
+            result = ((sub =~ /^#{x}/i).nil? ? false : true)
+            return true if result
+          end
+          return false
+        end
+      else
+        raise TypeError, "Unsupported class #{pattern.class} in Cotcube::Core::sub"
+      end
+    end
+  end
+end

data/lib/cotcube-helpers/swig/date.rb

@@ -0,0 +1,66 @@
+class Time
+  def to_centi
+    (self.to_f * 1000.0).to_i
+  end
+
+  def to_part(x=100)
+    (self.to_f * x.to_f).to_i % x
+  end
+end
+
+
+class Date
+  def abbr_dayname
+    ABBR_DAYNAMES[self.wday]
+  end
+
+  def to_string
+    self.strftime("%Y-%m-%d")
+  end
+
+  def to_timestring
+    self.strftime("%Y-%m-%d-%H-%M-%S")
+  end
+
+end
+
+class String
+  def to_date
+    Date::strptime(self, "%Y-%m-%d")
+  end
+
+  def to_time
+    DateTime::strptime(self, "%s")
+  end
+end
+
+class Integer
+  def to_tz
+    return "+0000" if self == 0
+    sign    = self > 0 ? "+" : "-"
+    value   = self.abs
+    hours   = (value / 3600.to_f).floor
+    minutes = ((value - 3600 * hours) / 60).floor
+    "#{sign}#{hours>9 ? "" : "0"}#{hours}#{minutes<10 ? "0" : "" }#{minutes}"
+  end
+
+  def to_tod(zone="UTC") 
+    self.to_time
+      #in_time_zone(zone).
+      #to_time_of_day
+  end
+
+  def to_tod_i
+    (self / 100).to_time.strftime("%H%M%S").to_i
+  end
+
+  def to_date
+    Date::strptime(self.to_s, "%s")
+  end
+
+  def to_time
+    DateTime.strptime(self.to_s, "%s")
+  end
+
+end
+

data/lib/cotcube-helpers/swig/fill_x.rb

@@ -0,0 +1,57 @@
+module Tritangent
+  module Helpers
+    include ::Tod
+    #Notice the first use of keyword arguments here ;)
+    def fill_x (base:, discretion:, time:, attr:, maintenance: nil, zone: nil)
+      zone ||= case base[0][time].zone
+               when 'CDT','CT','CST'
+                 "America/Chicago"
+               when 'EDT', 'ET', 'EST'
+                 "AMerica/New_York"
+               else
+                 "UTC"
+               end
+                 
+      maintenance ||= case zone
+                      when "America/Chicago"
+                        { 0 => Shift.new(Tod::TimeOfDay.new( 0), Tod::TimeOfDay.new(17), true),
+  			  1 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+			  2 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+		  	  3 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+		 	  4  => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+			  5 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new( 0), true)
+                        }
+                      when "America/New_York"
+                        { 0 => Tod::Shift.new(Tod::TimeOfDay.new( 0), Tod::TimeOfDay.new(17), true),
+                          1 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+                          2 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+                          3  => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+                          4 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new(17), true),
+                          5 => Tod::Shift.new(Tod::TimeOfDay.new(16), Tod::TimeOfDay.new( 0), true)
+                        }
+                      else
+                        raise "Tritangent::Helpers.fill_x needs :maintenance or :zone"
+                      end
+
+      tz = Time.find_zone zone
+      exchange_open = lambda do |t0|
+        current_week_day = t0.wday
+        return false if current_week_day == 6
+        not maintenance[current_week_day].include?(Tod::TimeOfDay(t0.in_time_zone(zone)))
+      end
+      result = [] # [ { time => base.first[time], attr => base.first[attr] } ]
+      i = 0
+      timer = base.first[time]
+      while not base[i].nil?
+        if timer == base[i][time] 
+          result << {  time => timer, attr => base[i][attr] } 
+          i += 1
+        else 
+          result << {  time => timer } if exchange_open.call(timer)
+        end
+        timer += discretion
+      end
+      result
+    end
+  end
+end

data/lib/cotcube-helpers/swig/recognition.rb

@@ -0,0 +1,330 @@
+module Candlestick_Recognition
+
+  extend self
+
+  def candles(candles, debug = false)
+    candles.each_with_index do |bar, i| 
+      # rel simply sets a grace limit based on the full height of the bar, so we won't need to use the hard limit of zero
+      begin 
+        rel  = (bar[:high] - bar[:low]) * 0.1
+      rescue 
+        puts "Warning, found inappropriate bar".light_white + " #{bar}"
+        raise
+      end
+      bar[:rel]        = rel
+
+      bar[:upper]      = [bar[:open], bar[:close]].max
+      bar[:lower]      = [bar[:open], bar[:close]].min
+      bar[:bar_size]   = (bar[:high] - bar[:low])
+      bar[:body_size]       = (bar[:open] - bar[:close]).abs
+      bar[:lower_wick] = (bar[:lower] - bar[:low])
+      bar[:upper_wick] = (bar[:high] - bar[:upper])
+      bar.each{|k,v| bar[k] = v.round(8) if v.is_a? Float}
+
+      # a doji's open and close are same (or only differ by rel)
+      bar[:doji]    = true if bar[:body_size] <= rel and bar[:dist] >= 3
+      bar[:tiny]    = true if bar[:dist] <= 5
+
+      next if bar[:tiny]
+
+      bar[:bullish]  = true if not bar[:doji] and bar[:close] > bar[:open]
+      bar[:bearish]  = true if not bar[:doji] and bar[:close] < bar[:open]
+
+      bar[:spinning_top] = true if bar[:body_size]       <= bar[:bar_size] / 4 and 
+        bar[:lower_wick] >= bar[:bar_size] / 4 and
+        bar[:upper_wick] >= bar[:bar_size] / 4
+
+      # a marubozu open at high or low and closes at low or high
+      bar[:marubozu] = true if bar[:upper_wick] < rel and bar[:lower_wick] < rel
+
+      # a bar is considered bearish if it has at least a dist of 5 ticks and it's close it near high (low resp)
+      bar[:bullish_close] = true if (bar[:high] - bar[:close]) <= rel and not bar[:marubozu]
+      bar[:bearish_close] = true if (bar[:close] - bar[:low])  <= rel and not bar[:marubozu]
+
+      # the distribution of main volume is shown in 5 segments, like [0|0|0|4|5] shows that most volume concentrated at the bottom, [0|0|3|0|0] is heavily centered
+      # TODO
+
+    end 
+    candles
+  end
+
+  def comparebars(prev, curr)
+    bullishscore  = 0
+    bearishscore  = 0
+    bullishscore += 1 if prev[:high]  <= curr[:high]
+    bullishscore += 1 if prev[:low]   <= curr[:low]
+    bullishscore += 1 if prev[:close] <= curr[:close]
+    bearishscore += 1 if prev[:close] >= curr[:close]
+    bearishscore += 1 if prev[:low]   >= curr[:low]
+    bearishscore += 1 if prev[:high]  >= curr[:high]
+    r = {}
+    r[:bullish] = true if bullishscore >= 2
+    r[:bearish] = true if bearishscore >= 2
+    return r
+  end
+
+
+  def patterns(candles, debug = false)
+    candles.each_with_index do |bar, i|
+      if i.zero?
+        bar[:slope] = 0
+        next
+      end
+      pprev= candles[i-2]
+      prev = candles[i-1]
+      succ = candles[i+1]
+
+      bar[:tr]       = [ bar[:high], prev[:close] ].max - [bar[:low], prev[:close]].min
+      bar[:ranges]   = prev[:ranges].nil? ? [ bar[:tr] ] : prev[:ranges] + [ bar[:tr] ] 
+      bar[:ranges].shift while bar[:ranges].size > 5
+      bar[:atr]      = (bar[:ranges].reduce(:+) / bar[:ranges].size.to_f).round(8) if bar[:ranges].size > 0
+
+      bar[:vranges]  = prev[:vranges].nil? ? [ bar[:volume] ] : prev[:vranges] + [ bar[:volume] ] 
+      bar[:vranges].shift while bar[:vranges].size > 5
+      bar[:vavg]     = (bar[:vranges].reduce(:+) / bar[:vranges].size.to_f).round  if bar[:vranges].compact.size > 0
+
+
+
+      # VOLUME
+      if bar[:volume] > bar[:vavg] * 1.3
+        bar[:BREAKN_volume] = true 
+      elsif bar[:volume] >= bar[:vavg] * 1.1
+        bar[:RISING_volume] = true 
+      elsif bar[:volume] <  bar[:vavg]   * 0.7
+        bar[:FAINTN_volume] = true
+      elsif bar[:volume] <= bar[:vavg]  * 0.9 
+        bar[:FALLIN_volume] = true
+      else
+        bar[:STABLE_volume] = true
+      end
+
+      # GAPS 
+      bar[:bodygap] = true if bar[:lower] > prev[:upper] or bar[:upper] < prev[:lower] 
+      bar[:gap]     = true if bar[:low] > prev[:high] or bar[:high] < prev[:low]
+
+
+      bar[:slope] = slopescore(pprev, prev, bar, debug)
+
+      # UPPER_PIVOTs define by having higher highs and higher lows than their neighor
+      bar[:UPPER_ISOPIVOT] = true if succ and prev[:high]  < bar[:high] and prev[:low] <= bar[:low] and succ[:high] <  bar[:high] and succ[:low] <= bar[:low] and bar[:lower] >= [prev[:upper], succ[:upper]].max
+      bar[:LOWER_ISOPIVOT] = true if succ and prev[:high] >= bar[:high] and prev[:low] >  bar[:low] and succ[:high] >= bar[:high] and succ[:low] >  bar[:low] and bar[:upper] <= [prev[:lower], succ[:lower]].min
+      bar[:UPPER_PIVOT] = true if succ and prev[:high]  < bar[:high] and prev[:low] <= bar[:low] and succ[:high] <  bar[:high] and succ[:low] <= bar[:low] and not bar[:UPPER_ISOPIVOT]
+      bar[:LOWER_PIVOT] = true if succ and prev[:high] >= bar[:high] and prev[:low] >  bar[:low] and succ[:high] >= bar[:high] and succ[:low] >  bar[:low] and not bar[:LOWER_ISOPIVOT]
+
+      # stopping volume is defined as high volume candle during downtrend then closes above mid candle (i.e. lower_wick > body_size)
+      bar[:stopping_volume] = true if bar[:BREAKN_volume] and prev[:slope] < -5 and bar[:lower_wick] >= bar[:body_size]
+      bar[:stopping_volume] = true if bar[:BREAKN_volume] and prev[:slope] >  5 and bar[:upper_wick] >= bar[:body_size]
+      bar[:volume_lower_wick] = true if bar[:vhigh] and (bar[:vol_i].nil? or bar[:vol_i] >= 2) and bar[:vhigh] <= bar[:lower] and not bar[:FAINTN_volume] and not bar[:FALLIN_volume]
+      bar[:volume_upper_wick] = true if bar[:vlow]  and (bar[:vol_i].nil? or bar[:vol_i] >= 2) and bar[:vlow]  >= bar[:upper] and not bar[:FAINTN_volume] and not bar[:FALLIN_volume]
+
+
+      ###################################
+      # SINGLE CANDLE PATTERNS 
+      ################################### 
+
+      # a hammer is a bar, whose open or close is at the high and whose body is lte 1/3 of the size, found on falling slope, preferrably gapping away
+      bar[:HAMMER]          = true if bar[:upper_wick] <=  bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3 and bar[ :slope] <= -6
+      # same shape, but found at a raising slope without the need to gap away
+      bar[:HANGING_MAN]     = true if bar[:upper_wick] <=  bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3 and prev[:slope] >=  6
+
+      # a shooting star is the inverse of the hammer, while the inverted hammer is the inverse of the hanging man
+      bar[:SHOOTING_STAR]   = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] <= bar[:bar_size] / 2.5 and bar[ :slope] >= 6      
+      bar[:INVERTED_HAMMER] = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] <= bar[:bar_size] / 3   and prev[:slope] <= -6
+
+      # a star is simply gapping away the preceding slope
+      bar[:STAR]      = true if ((bar[:lower] >= prev[:upper] and bar[:slope] >= 6) or (bar[:upper] <= prev[:lower] and bar[:slope] <= -6)) and not bar[:doji]
+      bar[:DOJI_STAR] = true if ((bar[:lower] >= prev[:upper] and bar[:slope] >= 6) or (bar[:upper] <= prev[:lower] and bar[:slope] <= -6)) and     bar[:doji]
+
+      # a belthold is has a gap in the open, but reverses strong
+      bar[:BULLISH_BELTHOLD] = true if bar[:lower_wick] <= bar[:rel] and bar[:body_size] >= bar[:bar_size] / 2 and 
+                                       prev[:slope] <= -4 and bar[:lower] <= prev[:low ] and bar[:bullish] and not prev[:bullish] and bar[:bar_size] >= prev[:bar_size]
+      bar[:BEARISH_BELTHOLD] = true if bar[:upper_wick] <= bar[:rel] and bar[:body_size] >= bar[:bar_size] / 2 and 
+                                       prev[:slope] >= -4 and bar[:upper] <= prev[:high] and bar[:bearish] and not prev[:bearish] and bar[:bar_size] >= prev[:bar_size]
+
+
+      ###################################
+      # DUAL CANDLE PATTERNS
+      ###################################
+
+
+      # ENGULFINGS
+      bar[:BULLISH_ENGULFING] = true if bar[:bullish] and prev[:bearish] and bar[:lower] <= prev[:lower] and bar[:upper] >  prev[:upper] and prev[:slope] <= -6
+      bar[:BEARISH_ENGULFING] = true if bar[:bearish] and prev[:bullish] and bar[:lower] <  prev[:lower] and bar[:upper] >= prev[:upper] and prev[:slope] >=  6
+
+
+      # DARK-CLOUD-COVER / PIERCING-LINE (on-neck / in-neck / thrusting / piercing / PDF pg 63)
+      bar[:DARK_CLOUD_COVER]  = true if bar[:slope] > 5  and prev[:bullish] and bar[:open] > prev[:high] and bar[:close] < prev[:upper] - prev[:body_size] * 0.5  and 
+                                                         not bar[:BEARISH_ENGULFING]
+      bar[:PIERCING_LINE]     = true if bar[:slope] < -5 and prev[:bearish] and bar[:open] < prev[:low ] and bar[:close] > prev[:lower] + prev[:body_size] * 0.5  and 
+                                                         not bar[:BULLISH_ENGULFING]
+      bar[:SMALL_CLOUD_COVER] = true if bar[:slope] > 5  and prev[:bullish] and bar[:open] > prev[:high] and bar[:close] < prev[:upper] - prev[:body_size] * 0.25 and 
+                                                         not bar[:BEARISH_ENGULFING] and not bar[:DARK_CLOUD_COVER]
+      bar[:THRUSTING_LINE]    = true if bar[:slope] < -5 and prev[:bearish] and bar[:open] < prev[:low ] and bar[:close] > prev[:lower] + prev[:body_size] * 0.25 and 
+                                                         not bar[:BULLISH_ENGULFING] and not bar[:PIERCING_LINE]
+
+
+      # COUNTER ATTACKS are like piercings / cloud covers, but insist on a large reverse while only reaching the preceding close
+      bar[:BULLISH_COUNTERATTACK] = true if bar[:slope] < 6 and prev[:bearish] and bar[:bar_size] > bar[:atr] * 0.66 and (bar[:close] - prev[:close]).abs < 2 * bar[:rel] and 
+                                            bar[:body_size] >= bar[:bar_size] * 0.5 and bar[:bullish]
+      bar[:BEARISH_COUNTERATTACK] = true if bar[:slope] > 6 and prev[:bullish] and bar[:bar_size] > bar[:atr] * 0.66 and (bar[:close] - prev[:close]).abs < 2 * bar[:rel] and
+                                            bar[:body_size] >= bar[:bar_size] * 0.5 and bar[:bearish]
+
+
+      # HARAMIs are an unusual long body embedding the following small body
+      bar[:HARAMI]       = true if bar[:body_size] < prev[:body_size] / 2.5 and prev[:bar_size] >= bar[:atr] and 
+                                  prev[:upper] > bar[:upper] and prev[:lower] < bar[:lower] and not bar[:doji]
+      bar[:HARAMI_CROSS] = true if bar[:body_size] < prev[:body_size] / 2.5 and prev[:bar_size] >= bar[:atr] and
+                                  prev[:upper] > bar[:upper] and prev[:lower] < bar[:lower] and     bar[:doji]
+      if bar[:HARAMI] or bar[:HARAMI_CROSS]
+        puts [ :date, :open, :high, :low, :close, :upper, :lower ].map{|x| prev[x]}.join("\t") if debug
+        puts [ :date, :open, :high, :low, :close, :upper, :lower ].map{|x| bar[ x]}.join("\t") if debug
+        puts  "" if debug
+      end
+
+      # TODO TWEEZER_TOP and TWEEZER_BOTTOM
+      # actually being a double top / bottom, this dual candle pattern has to be unfolded. It is valid on daily or weekly charts, 
+      # and valid if 
+      #     1 it has an according 
+
+
+      ###################################
+      # TRIPLE CANDLE PATTERNS
+      ###################################
+
+      # morning star, morning doji star
+      next unless prev and pprev
+      bar[:MORNING_STAR]      = true if prev[:STAR]      and bar[:bullish] and bar[:close] >= pprev[:lower] and prev[:slope] < -6
+      bar[:MORNING_DOJI_STAR] = true if prev[:DOJI_STAR] and bar[:bullish] and bar[:close] >= pprev[:lower] and prev[:slope] < -6 
+      bar[:EVENING_STAR]      = true if prev[:STAR]      and bar[:bearish] and bar[:close] <= pprev[:upper] and prev[:slope] >  6
+      bar[:EVENING_DOJI_STAR] = true if prev[:DOJI_STAR] and bar[:bearish] and bar[:close] <= pprev[:upper] and prev[:slope] >  6
+
+      # the abandoned baby escalates above stars by gapping the inner star candle to both framing it
+      bar[:ABANDONED_BABY]    = true if (bar[:MORNING_STAR] or bar[:MORNING_DOJI_STAR]) and prev[:high] <= [ pprev[:low ], bar[:low ] ].min
+      bar[:ABANDONED_BABY]    = true if (bar[:EVENING_STAR] or bar[:EVENING_DOJI_STAR]) and prev[:low ] >= [ pprev[:high], bar[:high] ].max
+
+      # UPSIDEGAP_TWO_CROWS
+      bar[:UPSIDEGAP_TWO_CROWS] = true if (prev[:STAR] or prev[:DOJI_STAR]) and prev[:slope] > 4 and bar[:bearish] and prev[:bearish] and bar[:close] > pprev[:close]
+      bar[:DOWNGAP_TWO_RIVERS]  = true if (prev[:STAR] or prev[:DOJI_STAR]) and prev[:slope] < 4 and bar[:bullish] and prev[:bullish] and bar[:close] < pprev[:close]
+
+      # THREE BLACK CROWS / THREE WHITE SOLDIERS
+      bar[:THREE_BLACK_CROWS]   = true if [ bar, prev, pprev ].map{|x| x[:bearish] and x[:bar_size] > 0.5 * bar[:atr] }.reduce(:&) and 
+                                          pprev[:close] - prev[ :close] > bar[:atr] * 0.2 and 
+                                          prev[ :close] - bar[  :close] > bar[:atr] * 0.2
+      bar[:THREE_WHITE_SOLDIERS] = true if [ bar, prev, pprev ].map{|x| x[:bullish] and x[:bar_size] > 0.5 * bar[:atr] }.reduce(:&) and
+                                          prev[:close]  - pprev[:close] > bar[:atr] * 0.2 and 
+                                          bar[ :close]  - prev[ :close] > bar[:atr] * 0.2
+    end
+  end
+
+
+  # SLOPE SCORE
+  def slopescore(pprev, prev, bar, debug = false)
+    # the slope between to bars is considered bullish, if 2 of three points match
+    #     - higher high
+    #     - higher close
+    #     - higher low
+    # the opposite counts for bearish
+    # 
+    # this comparison is done between the current bar and previous bar
+    #     - if it confirms the score of the previous bar, the new slope score is prev + curr
+    #     - otherwise the is compared to score of the pprevious bar
+    #         - if it confirms there, the new slope score is pprev + curr
+    #         - otherwise the trend is destroyed and tne new score is solely curr
+
+    if bar[:bullish]
+      curr  = 1
+      curr += 1   if bar[:bullish_close]
+    elsif bar[:bearish]
+      curr  = -1 
+      curr -=  1  if bar[:bearish_close]
+    else
+      curr  = 0
+    end
+    puts "curr set to #{curr} @ #{bar[:date]}".yellow if debug
+    if prev.nil?
+      puts "no prev found, score == curr: #{curr}" if debug
+      score = curr
+    else
+      comp = comparebars(prev, bar)
+
+      puts prev.select{|k,v| [:high,:low,:close,:score].include?(k)} if debug
+      puts bar if debug
+      puts "COMPARISON 1: #{comp}" if debug
+
+      if prev[:slope] >= 0 and comp[:bullish]     # bullish slope confirmed
+        score  = prev[:slope]
+        score += curr if curr > 0
+        [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] }
+        score += 1 if bar[:RISING_volume]
+        score += 2 if bar[:BREAKN_volume]
+        puts "found bullish slope confirmed, new score #{score}" if debug
+      elsif prev[:slope] <= 0 and comp[:bearish]  # bearish slope confirmed
+        score  = prev[:slope] 
+        score += curr if curr < 0
+        [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] }
+        score -= 1 if bar[:RISING_volume]
+        score -= 2 if bar[:BREAKN_volume]
+        puts "found bearish slope confirmed, new score #{score} (including #{curr} and #{bar[:bodygap]} and #{bar[:gap]}" if debug
+      else #if prev[:slope] > 0                     # slopes failed
+        puts "confirmation failed: " if debug
+        if pprev.nil? 
+          score = curr
+        else
+          comp2 = comparebars(pprev, bar)
+          puts "\t\tCOMPARISON 2: #{comp2}" if debug
+          if pprev[:slope] >= 0 and comp2[:bullish]     # bullish slope confirmed on pprev
+            score  = pprev[:slope]
+            score += curr if curr > 0
+            [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] }
+            puts "\t\tfound bulliish slope confirmed, new score #{score}" if debug
+            score += 1 if bar[:RISING_volume]
+            score += 2 if bar[:BREAKN_volume]
+          elsif pprev[:slope] <= 0 and comp2[:bearish]  # bearish slope confirmed
+            score  = pprev[:slope]
+            score += curr if curr < 0
+            [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] }
+            score -= 1 if bar[:RISING_volume]
+            score -= 2 if bar[:BREAKN_volume]
+            puts "\t\tfound bearish slope confirmed, new score #{score}" if debug
+          else                                          #slope confirmation finally failed
+            comp3 = comparebars(pprev, prev)
+            if prev[:slope] > 0 # was bullish, turning bearish now
+              score  = curr                     
+              score -= 1 if comp3[:bearish]
+              score -= 1 if comp[:bearish]
+              score -= 1 if prev[:bearish]
+              score -= 1 if prev[:RISING_volume] and comp3[:bearish]
+              score -= 2 if prev[:BREAKN_volume] and comp3[:bearish]
+              score -= 1 if bar[:RISING_volume] and comp[:bearish]
+              score -= 2 if bar[:BREAKN_volume] and comp[:bearish]
+              score -= 1 if bar[:RISING_volume] and comp[:bearish]
+              score -= 2 if bar[:BREAKN_volume] and comp[:bearish]
+              [ :gap, :bodygap ] .each {|x| score += 0.5  if bar[x] } 
+              puts "\t\tfinally gave up, turning bearish now, new score #{score}" if debug
+            elsif prev[:slope] < 0
+              score = curr
+              score += 1 if comp3[:bullish]
+              score += 1 if comp[:bullish]
+              score += 1 if prev[:bullish]
+              score += 1 if prev[:RISING_volume] and comp3[:bullish]
+              score += 2 if prev[:BREAKN_volume] and comp3[:bullish]
+              score += 1 if bar[:RISING_volume] and comp[:bullish]
+              score += 2 if bar[:BREAKN_volume] and comp[:bullish]
+              score += 1 if bar[:RISING_volume] and comp[:bullish]
+              score += 2 if bar[:BREAKN_volume] and comp[:bullish]
+              [ :gap, :bodygap ] .each {|x| score -= 0.5  if bar[x] } if curr < 0
+              puts "\t\tfinally gave up, turning bullish now, new score #{score}" if debug
+            else
+              score = 0
+            end
+          end
+        end
+      end
+    end
+    puts "" if debug
+    score
+  end
+
+end
+
+CR = Candlestick_Recognition

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: cotcube-helpers
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Benjamin L. Tischendorf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Some helpers and core extensions as part of the Cotcube Suite...
+email:
+- donkeybridge@jtown.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".irbrc.rb"
+- CHANGELOG.md
+- Gemfile
+- VERSION
+- cotcube-helpers.gemspec
+- lib/cotcube-helpers.rb
+- lib/cotcube-helpers/array_ext.rb
+- lib/cotcube-helpers/enum_ext.rb
+- lib/cotcube-helpers/hash_ext.rb
+- lib/cotcube-helpers/input.rb
+- lib/cotcube-helpers/parallelize.rb
+- lib/cotcube-helpers/range_ext.rb
+- lib/cotcube-helpers/simple_output.rb
+- lib/cotcube-helpers/string_ext.rb
+- lib/cotcube-helpers/subpattern.rb
+- lib/cotcube-helpers/swig/date.rb
+- lib/cotcube-helpers/swig/fill_x.rb
+- lib/cotcube-helpers/swig/recognition.rb
+homepage: https://github.com/donkeybridge/cotcube-helpers
+licenses:
+- BSD-4-Clause
+metadata:
+  homepage_uri: https://github.com/donkeybridge/cotcube-helpers
+  source_code_uri: https://github.com/donkeybridge/cotcube-helpers
+  changelog_uri: https://github.com/donkeybridge/cotcube-helpers/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.7'
+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: Some helpers and core extensions as part of the Cotcube Suite.
+test_files: []