cotcube-level 0.3.1 → 0.3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7756ccc0318477cf223fc205720c986daaaad4304439108b960ca410a15acf79
-  data.tar.gz: ba7a79e928da4c89b0e7103394899096ab42f5977986892c5e7396fe5d4abeff
+  metadata.gz: 71bc6b4ca29ab4ff089b95568a0d592d4bc2b3d8c1824ea9158d661792f1c5b7
+  data.tar.gz: 670d5a69457411fc7539542a1bd0ad1712ef9111f7b5a876b3c7bdd5d6de90c0
 SHA512:
-  metadata.gz: ceb38b4a6c827b0d8a7b09e0c0f86e9050e49dce54504cf5075d2d2da5fb9fe99186c8e9aa3403a14b61d5d6fa831e86a43886279dea8e20efd1c818e119d1f0
-  data.tar.gz: f53b20c6848b4d7cc825a18819ace61ebade1238706dbd125e76318eeb2dd1e4abbc6dca2d9872accb0069df8ac9edb16762c45ea7bc9a8293b95452d36102a6
+  metadata.gz: 3221bf00e3532ae51f62d98f191332273a2241ae34f0eff99e9840f28f41e339a816d23d100150aca70719855c6a1d0507f6509f2598cad75c880f86089286b3
+  data.tar.gz: 652072c05872418b438ca7ac937e3e5735a5967804c0d0e8f75b4e5381553b55e8b64ecf769cb820745650717077eae1ac7b0b844325725a1c0c78b6b2fbbf85

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## 0.3.4.1 (October 09, 2021)
+  - intraday_stencil: fixing @index, that did not work when used outside active hours
+
+## 0.3.4 (October 06, 2021)
+  - intraday_stencil: major rework resp. rebuild ... now beta-ready
+  - helpers: preparing puts_swap and get_jsonl_name to work intraday
+  - puts_swap: changed output scheme to provide exceedance as NOTE
+
+## 0.3.3 (October 05, 2021)
+  - helpers::load_swaps: added :exceed to allow 1(sic) swap to be exceeded while loading
+  - tritangulate: added :manual for feature of manual swap creation with base of 2 members
+  - helpers::load_swap added :digest to filter for swaps starting with pattern
+  - helpers: minor readability improvements
+  - eod_stencil: minor readability improvements
+  - helpers: few optimizations
+
+## 0.3.2 (August 29, 2021)
+  - tritangulate: fixing 'finalize', as Integer zero won't comparte to Float zero
+  - cotcube-level.rb: added :check_exceedance
+  - helpers:member_to_human: added :daily param to distinguish stencils
+  - tritangulate: added 'min_ratio' as param with lambda
+  - eod_stencil: added #use to calculate current swap line value / dist;
+  - tritangulate: added interval to be saved with the swap information.
+  - helpers: moved puts_swaps to puts_swap, and added a :short switch for 1-liners per swap
+
+## 0.3.1.1 (August 25, 2021)
+  - trying to fix versioning mistake
+  - Bump version to 0.3.2.1.
+  - minor fixes correcting mistakes sneaked in during documentation rework
+  - minor fix
+
+## 0.3.2.1 (August 25, 2021)
+  - minor fixes correcting mistakes sneaked in during documentation rework
+  - minor fix
+
 ## 0.3.1 (August 24, 2021)
   - renaming triangulation to tritangulation
   - minor fixes in README and gemspec

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.4.1

data/lib/cotcube-level/eod_stencil.rb

@@ -43,7 +43,6 @@ module Cotcube
         range: nil,                 # used to shrink the stencil size, accepts String or Date
         interval:,
         swap_type:,
-        contract: nil,
         date: nil,
         debug: false,
         version: nil,               # when referring to a specicic version of the stencil
@@ -54,7 +53,6 @@ module Cotcube
         @debug     = debug
         @interval  = interval == :continuous ? :daily : interval
         @swap_type = swap_type
-        @contract  = contract
         @warnings = warnings
         step =  case @interval
                 when :hours, :hour; 1.hour
@@ -108,7 +106,6 @@ module Cotcube
           interval:   @interval,
           swap_type:  @swap_type,
           date:       @date,
-          contract:   @contract,
           stencil:    @base.map{|x| x.dup}
         )
       end
@@ -139,6 +136,22 @@ module Cotcube
         to.reject!{|x| x[:x].nil? }
       end
 
+      def use(with:, sym:, zero:, grace: -2)
+        # todo: validate with (check if vslid swap
+        #                sym  (check keys)
+        #                zero (ohlc with x.zero?)
+        #                side ( upper or lower)
+        swap  = with.dup
+        high  = swap[:side] == :upper
+        ohlc  = high ? :high : :low
+        start = base.find{|x| swap[:datetime] == x[:datetime]}
+        swap[:current_change] = (swap[:tpi] * start[:x]).round(8)
+        swap[:current_value]  =  swap[:members].last[ ohlc ] + swap[:current_change] * sym[:ticksize]
+        swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
+        swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
+        swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        swap
+      end
     end
 
   end

data/lib/cotcube-level/helpers.rb

@@ -17,41 +17,62 @@ module Cotcube
         member[:yy] =
           member[:y] +
           (member[:dx].nil? ? member[:x] : member[:dx]) * tan
-        bar
+        member
       }
     end
 
     # human readable output
     # please note the format must be given, that should be taken from :sym
-    def member_to_human(member,side: ,format:)
-      high = side == :upper
-      "#{member[:datetime].strftime("%a, %Y-%m-%d %I:%M%p")
-        }  x: #{format '%-4d', member[:x]
+    def member_to_human(member,side: ,format:, daily: false)
+      high = (side == :upper)
+      "#{                         member[:datetime].strftime("%a, %Y-%m-%d#{daily ? "" :" %I:%M%p"}")
+        }  x: #{format '%-4d',    member[:x]
         } dx: #{format '%-8.3f', (member[:dx].nil? ? member[:x] : member[:dx].round(3))
             } #{high ? "high" : "low"
-           }: #{format format, member[high ? :high : :low]
-         } i: #{(format '%4d', member[:i]) unless member[:i].nil?
-         } d: #{format '%6.2f', member[:dev] unless member[:dev].nil?
+           }: #{format format,    member[high ? :high : :low]
+         } i: #{(format '%4d',    member[:i]) unless member[:i].nil?
+         } d: #{format '%6.2f',   member[:dev] unless member[:dev].nil?
             } #{member[:near].nil? ? '' : "near: #{member[:near]}"
          }"
     end
 
     # human readable output
-    # list all swaps contained in an array (e.g. result of tritangulate)
-    def puts_swaps(swaps, format: )
-      swaps = [ swaps ] unless swaps.is_a? Array
-      swaps.each do |swap|
+    # format: e.g. sym[:format]
+    # short:  print one line / less verbose
+    # notice: add this to output as well
+    def puts_swap(swap, format: , short: true, notice: nil, hash: 3)
+      return if swap[:empty]
+      daily =  %i[ continuous daily ].include?(swap[:interval].to_sym) rescue false
+      datetime_format = daily ? '%Y-%m-%d' : '%Y-%m-%d %I:%M %p'
+      high = swap[:side] == :high
+      ohlc = high ? :high : :low
+      if notice.nil? and swap[:exceeded]
+        notice = "exceeded #{swap[:exceeded].strftime(datetime_format)}"
+      end
+      if short
+        puts (hash ? "#{swap[:digest][...hash]}    ".colorize(:light_white) : '') +
+             "S: #{swap[:side]
+            } L: #{   format '%4d', swap[:length]
+            } R: #{   format '%4d', swap[:rating]
+            } D: #{   format '%4d', swap[:depth]
+            } P: #{   format '%10s', (format '%5.2f', swap[:ppi])
+            }   F: #{ format format, swap[:members].last[ ohlc ]
+            }   S: #{ swap[:members].first[:datetime].strftime(datetime_format)
+            } - #{    swap[:members].last[:datetime].strftime(datetime_format)
+            }#{"    NOTE: #{notice}" unless notice.nil?}".colorize(swap[:color] || :white )
+      else
         puts "side: #{swap[:side] }\tlen: #{swap[:length]}  \trating: #{swap[:rating]}".colorize(swap[:color] || :white )
         puts "diff: #{swap[:ticks]}\tdif: #{swap[:diff].round(7)}\tdepth: #{swap[:depth]}".colorize(swap[:color] || :white )
         puts "tpi:  #{swap[:tpi]  }\tppi: #{swap[:ppi]}".colorize(swap[:color] || :white )
-        swap[:members].each {|x| puts member_to_human(x, side: swap[:side], format: format) }
+        puts "NOTE: #{notice}".colorize(:light_white) unless notice.nil?
+        swap[:members].each {|x| puts member_to_human(x, side: swap[:side], format: format, daily: daily) }
       end
     end
 
     # create a standardized name for the cache files
     # and, on-the-fly, create these files plus their directory
     def get_jsonl_name(interval:, swap_type:, contract:, sym: nil)
-      raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include? interval
+      raise "Interval #{interval } is not supported, please choose from #{INTERVALS}" unless INTERVALS.include?(interval) || interval.is_a?(Integer)
       raise "Swaptype #{swap_type} is not supported, please choose from #{SWAPTYPES}" unless SWAPTYPES.include? swap_type
       sym ||= Cotcube::Helpers.get_id_set(contract: contract)
       root = '/var/cotcube/level'
@@ -66,42 +87,136 @@ module Cotcube
 
     # the name says it all.
     # just note the addition of a digest, that serves to check whether same swap has been yet saved
-    # to the cache
-    def save_swaps(swaps, interval:, swap_type:, contract:, sym: nil)
+    # to the cache.
+    #
+    # there are actually 3 types of information, that are saved here:
+    # 1. a swap
+    # 2. an 'empty' information, referring to an interval that has been processed but no swaps were found
+    # 3. an 'exceeded' information, referring to another swap, that has been exceeded
+    #
+    def save_swaps(swaps, interval:, swap_type:, contract:, sym: nil, quiet: false)
       file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
+      swaps = [ swaps ] unless swaps.is_a? Array
       swaps.each do |swap|
-        swap_json = swap.to_json
+        raise "Illegal swap info: Must contain keys :datetime, :side... #{swap}" unless (%i[ datetime side ] - swap.keys).empty?
+        %i[ interval swap_type ].map {|key| swap.delete(key) }
+        sorted_keys = [ :datetime, :side ] + ( swap.keys - [ :datetime, :side ])
+        swap_json = swap.slice(*sorted_keys).to_json
         digest = Digest::SHA256.hexdigest swap_json
-        res = `cat #{file} | grep #{digest}`.strip
+        res = `cat #{file} | grep '"digest":"#{digest}"'`.strip
         unless res.empty?
-          puts "Cannot save swap, it is already in #{file}:"
-          p swap
+          puts "Cannot save swap, it is already in #{file}:".light_red unless quiet
+          p swap unless quiet
         else
           swap[:digest] = digest
-          File.open(file, 'a+'){|f| f.write(swap.to_json + "\n") }
+          sorted_keys += %i[digest]
+          File.open(file, 'a+'){|f| f.write(swap.slice(*sorted_keys).to_json + "\n") }
         end
       end
     end
 
     # loading of swaps is also straight forward
     # it takes few more efforts to normalize the values to their expected format
-    def load_swaps(interval:, swap_type:, contract:, sym: nil)
+    def load_swaps(interval:, swap_type:, contract:, sym: nil, datetime: nil, recent: false, digest: nil, quiet: false, exceed: false)
       file = get_jsonl_name(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
       jsonl = File.read(file)
-      jsonl.
+      data = jsonl.
         each_line.
         map do |x|
         JSON.parse(x).
           deep_transform_keys(&:to_sym).
           tap do |sw|
-          sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
-          sw[:side]     = sw[:side].to_sym
-          unless sw[:empty]
-            sw[:color]    = sw[:color].to_sym
-            sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
+            sw[:datetime] = DateTime.parse(sw[:datetime]) rescue nil
+            (sw[:exceeded] = DateTime.parse(sw[:exceeded]) rescue nil) if sw[:exceeded]
+            sw[:interval] = interval
+            sw[:swap_type] = swap_type
+            sw[:contract] = contract
+            %i[ side ].each {|key| sw[key] = sw[key].to_sym rescue false }
+            unless sw[:empty] or sw[:exceeded]
+              sw[:color]    = sw[:color].to_sym
+              sw[:members].map{|mem| mem[:datetime] = DateTime.parse(mem[:datetime]) }
+            end
+        end
+      end
+      # assign exceedance data to actual swaps
+      data.select{|swap| swap[:exceeded] }.each do |exc|
+        swap = data.find{|ref| ref[:digest] == exc[:ref]}
+        raise RuntimeError, "Inconsistent history for '#{exc}'. Origin not found." if swap.nil?
+        swap[:exceeded] = exc[:exceeded]
+      end
+      # do not return bare exceedance information
+      data.reject!{|swap| swap[:exceeded] and swap[:members].nil? }
+      # do not return swaps that are found 'later'
+      data.reject!{|swap| swap[:datetime] > datetime } unless datetime.nil?
+      # do not return exceeded swaps, that are exceeded in the past
+      recent  = 7.days  if recent.is_a? TrueClass
+      recent += 5.hours if recent
+      data.reject!{|swap| swap[:exceeded] and swap[:exceeded] < datetime - (recent ? recent : 0) } unless datetime.nil?
+      # remove exceedance information that is found 'later'
+      data.map{|swap| swap.delete(:exceeded) if swap[:exceeded] and swap[:exceeded] > datetime} unless datetime.nil?
+      unless digest.nil?
+        data.select! do |z|
+          (Cotcube::Helpers.sub(minimum: digest.length){ z[:digest] } === digest) and
+          not z[:empty]
+        end
+        case data.size
+        when 0
+          puts "No swaps found for digest '#{digest}'." unless quiet
+        when 1
+          sym ||= Cotcube::Helpers.get_id_set(contract: contract)
+          if not quiet or exceed
+            puts "Found 1 digest: "
+            data.each {|d| puts_swap( d, format: sym[:format], short: true, hash: digest.size + 2) }
+            if exceed
+              exceed = DateTime.now if exceed.is_a? TrueClass
+              mark_exceeded(swap: data.first, datetime: exceed)
+              puts "Swap marked exceeded."
+            end
+          end
+        else
+          sym ||= Cotcube::Helpers.get_id_set(contract: contract)
+          unless quiet
+            puts "Too many digests found for digest '#{digest}', please consider sending more figures: "
+            data.each {|d| puts_swap( d, format: sym[:format], short: true, hash: digest.size + 3)}
           end
         end
       end
+      data
+    end
+
+    # :swaps is an array of swaps
+    # :zero  is the current interval (ohlc)
+    # :stencil is the according current stencil (eod or intraday)
+    def check_exceedance(swaps:, zero:, stencil:, contract:, sym:, debug: false)
+      swaps.map do |swap|
+        # swaps cannot exceed the day they are found (or if they are found in the future)
+        next if  swap[:datetime] >= zero[:datetime] or swap[:empty]
+        update = stencil.use with: swap, sym: sym, zero: zero
+        if update[:exceeded]
+          to_save = {
+            datetime: zero[:datetime],
+            ref:      swap[:digest],
+            side:     swap[:side],
+            exceeded: update[:exceeded]
+          }
+          save_swaps to_save, interval: swap[:interval], swap_type: swap[:swap_type], contract: contract, sym: sym, quiet: (not debug)
+          swap[:exceeded] = update[:exceeded]
+        end
+        %i[ current_change current_value current_diff current_dist ].map{|key| swap[key] = update[key] }
+        swap
+      end.compact
+    end
+
+    def mark_exceeded(swap:, datetime:, debug: false)
+      to_save = {
+        datetime: datetime,
+        ref:      swap[:digest],
+        side:     swap[:side],
+        exceeded: datetime
+      }
+      save_swaps to_save, interval: swap[:interval], swap_type: swap[:swap_type], sym: Cotcube::Helpers.get_id_set(contract: swap[:contract]), contract: swap[:contract], quiet: (not debug)
+      swap[:exceeded] = datetime
+      swap
     end
 
   end

data/lib/cotcube-level/intraday_stencil.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Cotcube
   module Level
-    # TODO: Missing documentation of shiftsets, swap_types and stencil_types
+
     class Intraday_Stencil
 
-      GLOBAL_SOW = { 'CT' => '0000-1700' }
-      GLOBAL_EOW = { 'CT' => '1700-0000' }
-      GLOBAL_EOD = { 'CT' => '1600-1700' }
 
+      # Class method that loads the (latest) shiftset for given asset
+      # These raw stencils are located in /var/cotcube/level/stencils/shiftsets.csv
+      #
 
       def self.shiftset(asset:, sym: nil)
         shiftset_file = '/var/cotcube/level/stencils/shiftsets.csv'
@@ -18,45 +20,53 @@ module Cotcube
         sym ||= Cotcube::Helpers.get_id_set(symbol: asset)
         current_set = shiftsets.find{|s| s[:symbols] =~ /#{sym[:type]}/ }
         return current_set.tap{|s| headers.map{|h| s[h] = nil if s[h] == '---------' }; s[:rth5] ||= s[:rth]; s[:mpost5] ||= s[:mpost] }  unless current_set.nil?
-        raise "Cannot get shiftset for #{sym[:type]}: #{asset}, please prepare #{shiftset_file} before!" 
+        raise "Cannot get shiftset for #{sym[:type]}: #{asset}, please prepare #{shiftset_file} before!"
       end
 
       attr_reader :base, :shiftset, :timezone, :datetime, :zero, :index
 
-      # asset:    the asset the stencil will be applied to--or :full, if default stencil is desired
-      # datetime: the datetime that will become 'zero'. 
-      #           it will be calculated to the beginning of the previous interval
-      #           it must match the timezone of the asset
-      # interval: the interval as minutes
-      # weeks:    the amount of weeks before the beginning of the current week
-      # future:   the amount of weeks after  the beginning of the current week
-      def initialize(asset:, sym: nil, datetime:, interval:, weeks:, future: 1, debug: false, type:, base: )
-        @shiftset = Intraday_Stencils.shiftset(asset: asset)
-        @timezone = TIMEZONES[@shiftset[:tz]]
-        @debug    = debug
-        datetime  = @timezone.at(datetime.to_i) unless datetime.is_a? ActiveSupport::TimeWithZone
-        # slight flaw, as datetime does not carry the actuall timezone information but just the abbr. timezone name (like CDT or CEST)
-        raise "Zone mismatch: Timezone of asset is #{@timezone.now.zone} but datetime given is #{dateime.zone}" unless @timezone.now.zone == datetime.zone
-        @datetime = datetime.beginning_of_day
-        @datetime += interval while @datetime <= datetime - interval
-        @datetime -= interval 
+
+
+      def initialize(
+        asset:,
+        interval: 30.minutes,
+        swap_type: :full,
+        datetime: nil,
+        debug: false,
+        weeks: 6,
+        future: 2,
+        version: nil,               # when referring to a specicic version of the stencil
+        stencil: nil,               # instead of preparing, use this one if set
+        warnings: true              # be more quiet
+      )
+        @shiftset   = Intraday_Stencil.shiftset(asset: asset)
+        @timezone   = Cotcube::Level::TIMEZONES[@shiftset[:tz]]
+        @debug      = debug
+        @interval   = interval
+        @swap_type  = swap_type
+        @warnings   = warnings
+        datetime  ||= DateTime.now
+        datetime    = @timezone.at(datetime.to_i) unless datetime.is_a? ActiveSupport::TimeWithZone
+        @datetime   = datetime.beginning_of_day
+        @datetime  += interval while @datetime <= datetime - interval
+        @datetime  -= interval
+
         const = "RAW_INTRA_STENCIL_#{@shiftset[:nr]}_#{interval.in_minutes.to_i}".to_sym
         if Object.const_defined? const
           @base = (Object.const_get const).map{|z| z.dup}
         else
-
           start_time    = lambda {|x| @shiftset[x].split('-').first rescue '' }
           start_hours   = lambda {|x| @shiftset[x].split('-').first[ 0.. 1].to_i.send(:hours)   rescue 0 }
           start_minutes = lambda {|x| @shiftset[x].split('-').first[-2..-1].to_i.send(:minutes) rescue 0 }
           end_time      = lambda {|x| @shiftset[x].split('-').last  rescue '' }
           end_hours     = lambda {|x| @shiftset[x].split('-').last [ 0.. 1].to_i.send(:hours)   rescue 0 }
-          end_minutes   = lambda {|x| @shiftset[x].split('-').last [-2..-1].to_i.send(:minutes) rescue 0 } 
+          end_minutes   = lambda {|x| @shiftset[x].split('-').last [-2..-1].to_i.send(:minutes) rescue 0 }
 
-          runner = (@datetime - 
+         runner = (@datetime -
                     weeks * 7.days).beginning_of_week(:sunday)
           tm_runner = lambda { runner.strftime('%H%M') }
-          @base = [] 
-          (weeks+future).times do 
+          @base = []
+          (weeks+future).times do
             while tm_runner.call < GLOBAL_SOW[@shiftset[:tz]].split('-').last
               # if daylight is switched, this phase will be shorter or longer
               @base << { datetime: runner, type: :sow }
@@ -81,10 +91,10 @@ module Cotcube
                       yet_rth = true
                     end
                   end
-                  while ((sophase > eophase) ? (tm_runner.call >= sophase or tm_runner.call < eophase) : (tm_runner.call < eophase)) 
+                  while ((sophase > eophase) ? (tm_runner.call >= sophase or tm_runner.call < eophase) : (tm_runner.call < eophase))
                     current = { datetime: runner, type: phase }
                     if phase == :rth and not yet_rth
-                      current[:block] = true 
+                      current[:block] = true
                       yet_rth = true
                     end
                     @base << current
@@ -100,80 +110,104 @@ module Cotcube
             while runner < end_of_week
               @base << { datetime: runner, type: :eow }
               runner += interval
-            end     
+            end
           end
           Object.const_set(const, @base.map{|z| z.dup})
         end
-        self.apply to: base, type: type
-        @index = @base.index{|x| x[:datetime] == @datetime } 
-        @index -= 1 while %i[sow sod mpre mpost eod eow].include? @base[@index][:type] 
+
+        case swap_type
+        when :full
+          @base.select!{|x| %i[ pre rth post ].include?(x[:type]) }
+        when :rth
+          @base.select!{|x| x[:type] == :rth  }
+        when :flow
+          @base.reject!{|x| %i[ sow eow mpost mpost ].include?(x[:type]) }
+          @base.
+            map{ |x|
+            [:high, :low, :volume].map{|z| x[z] = nil} unless x[:type] == :rth
+          }
+        when :run
+          @base.select!{|x| %i[ pre rth post ].include? x[:type]}
+        else
+          raise ArgumentError, "Unknown stencil/swap type '#{swap_type}'"
+        end
+        @base.map!{|z| z.dup}
+
+        # zero is, were either x[:datetime] == @datetime (when we are intraday)
+        #         or otherwise {x[:datetime] <= @datetime}.last (when on maintenance)
+        @index = @base.index{|x| x == @base.select{|y| y[:datetime] <= @datetime }.last }
+        @index -= 1 while %i[sow sod mpre mpost eod eow].include? @base[@index][:type]
         @datetime = @base[@index][:datetime]
         @zero  = @base[@index]
-        counter = 0 
+        counter = 0
         while @base[@index - counter] and @index - counter >= 0
           @base[@index - counter][:x] = counter
           counter += 1
         end
-        counter = 0 
+        counter = 0
         while @base[@index + counter] and @index + counter < @base.length
           @base[@index + counter][:x] = -counter
           counter += 1
         end
-        @base.select!{|z| z[:x] <= 0 or z[:high]}
       end
 
-      def apply!(to:, type:) 
-        apply(to: to, type: type, force: true)
+=begin
+      def dup
+        Intraday_Stencil.new(
+          debug:      @debug,
+          interval:   @interval,
+          swap_type:  @swap_type,
+          datetime:   @datetime,
+          stencil:    @base.map{|x| x.dup}
+        )
       end
+=end
 
-      # :force will apply values to each bar regardless of existing ones
-      def apply(to:, type:, force: false, debug: false)
+      def zero
+        @zero ||=  @base.find{|b| b[:x].zero? }
+      end
+
+      def apply(to: )
         offset = 0
-        to.each_index do |i|
+        @base.each_index do |i|
           begin
-            offset += 1 while @base[i+offset][:datetime] < to[i][:datetime]
-            puts "#{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
+            offset += 1 while to[i+offset][:datetime] < @base[i][:datetime]
           rescue
             # appending
-            puts "appending #{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
-            @base << to[i]
+            to << @base[i]
             next
           end
-          if @base[i+offset][:datetime] > to[i][:datetime]
+          if to[i+offset][:datetime] > @base[i][:datetime]
             # skipping
-            puts "skipping #{i}\t#{offset}\t#{@base[i+offset][:datetime]} < #{to[i][:datetime]}" if debug
             offset -= 1
             next
           end
           # merging
-          j = i + offset
-          @base[j]=@base[j].merge(to[i]) if force or (@base[j][:high].nil? and @base[j][:low].nil?)
-          puts "MERGED:\t#{i}\t#{offset}\t#{@base[j]}" if debug
+          to[i+offset][:x] = @base[i][:x]
+          to[i+offset][:type] = @base[i][:type]
         end
         # finally remove all bars that do not belong to the stencil (i.e. holidays)
-        case type
-        when :full
-          @base.select!{|x| %i[ pre rth post ].include?(x[:type]) }
-        when :rth
-          @base.select!{|x| x[:type] == :rth  }
-          # to.map{    |x| [:high, :low, :volume].map{|z| x[z] = nil} if x[:block] } 
-        when :flow
-          @base.reject!{|x| %i[ meow postmm postmm5 ].include?(x[:type]) }
-          @base.
-            map{ |x| 
-            [:high, :low, :volume].map{|z| x[z] = nil} unless x[:type] == :rth 
-            # [:high, :low, :volume].map{|z| x[z] = nil} if x[:block]
-          }
-        when :run
-          @base.select!{|x| %i[ premarket rth postmarket ].include? x[:type]}
-        else
-          raise ArgumentError, "Unknown stencil/swap type '#{type}'"
-        end
-        @base.map!{|z| z.dup}
+        to.reject!{|x| x[:x].nil? }
       end
 
+      def use(with:, sym:, zero:, grace: -2)
+        # todo: validate with (check if vslid swap
+        #                sym  (check keys)
+        #                zero (ohlc with x.zero?)
+        #                side ( upper or lower)
+        swap  = with.dup
+        high  = swap[:side] == :upper
+        ohlc  = high ? :high : :low
+        start = base.find{|x| swap[:datetime] == x[:datetime]}
+        swap[:current_change] = (swap[:tpi] * start[:x]).round(8)
+        swap[:current_value]  =  swap[:members].last[ ohlc ] + swap[:current_change] * sym[:ticksize]
+        swap[:current_diff]   = (swap[:current_value] - zero[ohlc]) * (high ? 1 : -1 )
+        swap[:current_dist]   = (swap[:current_diff] / sym[:ticksize]).to_i
+        swap[:exceeded]       =  zero[:datetime] if swap[:current_dist] < grace
+        swap
+      end
     end
 
-    Intraday_Stencils = Intraday_Stencil
   end
+
 end

data/lib/cotcube-level/tritangulate.rb

@@ -9,15 +9,19 @@ module Cotcube
       range: (0..-1),       # range is relative to base
       max: 90,              # the range which to scan for swaps goes from deg 0 to max
       debug: false,
-      min_rating: 3,        # swaps having a lower rating are discarded
-      min_length: 8,        # shorter swaps are discared
+      min_rating: 3,        # 1st criteria: swaps having a lower rating are discarded
+      min_length: 8,        # 2nd criteria: shorter swaps are discared
+      min_ratio:            # 3rd criteria: the ratio between rating and length (if true, swap is discarded)
+        lambda {|r,l| r < l / 4.0 },
       save: true,           # allow saving  of results
       cached: true,         # allow loading of cached results
       interval: ,           # interval (currently) is one of %i[ daily continuous halfs ]
       swap_type: nil,       # if not given, a warning is printed and swaps won't be saved or loaded
       with_flaws: 0,        # the maximum amount of consecutive bars that would actually break the current swap
                             # should be set to 0 for dailies and I suggest no more than 3 for intraday
-      deviation: 2)         # the maximum shift of :x-values of found members
+      manual: false,        # some triggers must be set differently when manual entry is used
+      deviation: 2          # the maximum shift of :x-values of found members
+    )
 
       raise ArgumentError, "'0 < max < 90, but got '#{max}'" unless max.is_a? Numeric and 0 < max and max <= 90
       raise ArgumentError, 'need :side either :upper or :lower for dots' unless [:upper, :lower].include? side
@@ -26,7 +30,7 @@ module Cotcube
       # init some helpers
       #
       high       = side == :upper
-      # DELETE first      = base.to_a.find{|x|  not x[:high].nil? }
+      first      = base.to_a.find{|x|  not x[:high].nil? }
       zero       = base.select{|x| x[:x].zero? }
       raise ArgumentError, "Inappropriate base, it should contain ONE :x.zero, but contains #{zero.size}." unless zero.size==1
       zero       = zero.first
@@ -34,15 +38,16 @@ module Cotcube
       contract ||= zero[:contract]
       sym      ||= Cotcube::Helpers.get_id_set(contract: contract)
 
+
       if cached
         if interval.nil? or swap_type.nil?
           puts "Warning: Cannot use cache as both :interval and :swap_type must be given".light_yellow
         else
-          cache = load_swaps(interval: interval, swap_type: swap_type, contract: contract, sym: sym)
-          # if the current datetime has been yet processed but nothing has been found,
+          cache = load_swaps(interval: interval, swap_type: swap_type, contract: contract, sym: sym, datetime: zero[:datetime])
+          # if the current datetime was already processed but nothing has been found,
           # an 'empty' value is saved.
-          # that means, if neither an array of swaps nor :empty is found, the datetime has not been processed yet
-          selected = cache.select{|sw| sw[:datetime] == zero[:datetime] and sw[:side] == side}
+          # that means, if neither a swap (or more) nor :empty is found, the datetime has not been processed yet
+          selected = cache.select{|sw| sw[:datetime] == zero[:datetime] and sw[:side] == side }
           unless selected.empty?
             puts 'cache_hit'.light_white if debug
             return (selected.first[:empty] ? [] : selected )
@@ -66,8 +71,10 @@ module Cotcube
 
       # abs_peak is the absolute high / low of the base. the shearing operation ends there,
       # but results might be influenced when abs_peak becomes affected by :with_flaws
-      abs_peak = base.send(high ? :max_by : :min_by){|x| x[high ? :high : :low] }[:datetime]
-      base.reject!{|x| x[:datetime] < abs_peak}
+      unless manual
+        abs_peak = base.send(high ? :max_by : :min_by){|x| x[high ? :high : :low] }[:datetime]
+        base.reject!{|x| x[:datetime] < abs_peak}
+      end
 
       ###########################################################################################################################z
       # only if (and only if) the range portion above change the underlying base
@@ -100,13 +107,12 @@ module Cotcube
       finalize = lambda do |results|
         results.map do |result|
           result[:members].each  do |member|
-            next if member[:yy].nil? or member[:yy].zero?
+            next if member[:yy].nil? or member[:yy].round(PRECISION-5).zero?
 
             diff = (member[:x] - member[:dx]).abs / 2.0
             member[:dx] = member[:x] + diff
             # it employs another binary-search
-            while member[:yy].round(PRECISION) != 0
-              print '.' if debug
+            while member[:yy].round(PRECISION-5) != 0.0
               member[:yy] = shear_to_deg(deg: result[:deg], base: [ member ] ).first[:yy]
               diff /= 2.0
               if member[:yy] > 0
@@ -115,7 +121,7 @@ module Cotcube
                 member[:dx] -= diff
               end
             end
-            member[:yy] = member[:yy].abs.round(8)
+            member[:yy] = member[:yy].abs.round(PRECISION-5)
           end
 
           puts 'done!'.magenta if debug
@@ -152,7 +158,7 @@ module Cotcube
           # first member is solitary
           if new_members.empty?
             mem_sorted=members.sort
-            if mem_sorted[1] == mem_sorted[0] + 1
+            if mem_sorted[1] == mem_sorted[0] + 1 and not manual
               b2 = b[mem_sorted[1]..mem_sorted[-1]].map{|x| x.dup; x[:dx] = nil; x}
               puts 'starting recursive rerun'.light_red if debug
               alternative_slope = get_slope.call(b2)
@@ -174,7 +180,7 @@ module Cotcube
               current_slope[:members] << b[i] unless current_slope[:members].map{|x| x[:datetime]}.include? b[i][:datetime]
               current_slope[:members].sort_by!{|x| x[:datetime]}
             end
-            current_slope
+            return current_slope
 
           end
           # all new members found in current iteration have now receive their new :x value, depending on their distance to
@@ -215,6 +221,7 @@ module Cotcube
           swap_base      = shear_to_deg(base: swap_base, deg: swap[:deg])
           swap_base.map!{|x| x[:dev] = (x[:yy] / sym[:ticksize].to_f); x[:dev] = -( x[:dev] > 0 ? x[:dev].floor : x[:dev].ceil);  x}
           invalids       = swap_base.select{|x| x[:dev] < 0 }
+          with_flaws = 0 unless with_flaws # support legacy versions, where with_flaws was boolean
           if with_flaws > 0
             # TODO: this behaves only as expected when with_flaws == 2
             last_invalid   = invalids[(invalids[-2][:i] + 1 == invalids[-1][:i] ) ? -3 : -2] rescue nil
@@ -243,6 +250,8 @@ module Cotcube
           swap[:avg_dev]   = (swap_base.reject{|x| x[:dev].zero?}.map{|x| x[:dev].abs}.reduce(:+) / (swap_base.size - swap[:members].size).to_f).ceil rescue 0
           # depth:   the maximum distance to the swap line
           swap[:depth]     = swap_base.max_by{|x| x[:dev]}[:dev]
+          swap[:interval]  = interval
+          swap[:swap_type] = swap_type
           swap[:raw]       = swap[:members].map{|x| x[:x]}.reverse
           swap[:size]      = swap[:members].size
           swap[:length]    = swap[:raw][-1] - swap[:raw][0]
@@ -256,11 +265,11 @@ module Cotcube
           unless %i[ daily continuous ].include? interval
             swap[:color]     = ((rat > 150) ? :light_blue : (rat > 80) ? :magenta : (rat > 30) ? :light_magenta : (rat > 15) ? :light_yellow : high ? :green : :red)
           end
-          swap[:diff]      = swap[:members].last[ high ? :high : :low ] - swap[:members].first[ high ? :high : :low ]
+          swap[:diff]      = (swap[:members].last[ high ? :high : :low ] - swap[:members].first[ high ? :high : :low ]).round(8)
           swap[:ticks]     = (swap[:diff] / sym[:ticksize]).to_i
           # tpi:     ticks per interval, how many ticks are passed each :interval
           swap[:tpi]       = (swap[:ticks].to_f / swap[:length]).round(3)
-          # ppi:     power per interval, how many dollar value is passed each :interval
+          # ppi:     power per interval, how many $dollar value is passed each :interval
           swap[:ppi]       = (swap[:tpi] * sym[:power]).round(3)
         end # swap
       end # lambda
@@ -303,7 +312,7 @@ module Cotcube
       binding.irb if debug
 
       # reject all results that do not suffice
-      current_results.reject!{|swap| swap[:rating] < min_rating or swap[:length] < min_length or swap[:rating] < swap[:length] / 4.to_f}
+      current_results.reject!{|swap| swap[:rating] < min_rating or swap[:length] < min_length or min_ratio.call(swap[:rating],swap[:length])}
 
       #####################################################################################################################3
       # finally save results for caching and return them
@@ -312,7 +321,7 @@ module Cotcube
           puts "WARNING: Cannot save swaps, as both :interval and :swap_type must be given".colorize(:light_yellow)
         else
           current_results.map{|sw| mem = sw[:members]; sw[:slope] = (mem.last[:y] - mem.first[:y]) / (mem.last[mem.last[:dx].nil? ? :x : :dx] - mem.first[mem.first[:dx].nil? ? :x : :dx]).to_f }
-          to_save = current_results.empty? ? [ { datetime: zero[:datetime], side: side, empty: true } ] : current_results
+          to_save = current_results.empty? ? [ { datetime: zero[:datetime], side: side, empty: true, interval: interval, swap_type: swap_type } ] : current_results
           save_swaps(to_save, interval: interval, swap_type: swap_type, contract: contract, sym: sym)
         end
       end

data/lib/cotcube-level.rb

@@ -35,10 +35,11 @@ module Cotcube
                     :shear_to_rad,    # same all below
                     :rad2deg,
                     :deg2rad,
-                    :puts_swaps,
+                    :puts_swap,
                     :save_swaps,
                     :get_jsonl_name,
                     :load_swaps,
+                    :check_exceedance,
                     :member_to_human
     
     # please note that module_functions of sources provided in non-public files must slso be published within these

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cotcube-level
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.4.1
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-24 00:00:00.000000000 Z
+date: 2021-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -116,7 +116,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".irbrc.rb"
 - CHANGELOG.md
 - Gemfile
 - README.md

data/.irbrc.rb

@@ -1,12 +0,0 @@
-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-level'