cotcube-level 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7756ccc0318477cf223fc205720c986daaaad4304439108b960ca410a15acf79
-  data.tar.gz: ba7a79e928da4c89b0e7103394899096ab42f5977986892c5e7396fe5d4abeff
+  metadata.gz: 81e95a5e617ba6dd8fdf5df13c0395455ff19a337e2e72e79f485a37489049c0
+  data.tar.gz: d592daecc1be2e4686fd3a6807d82c5f5429de6b451b96e4aee30430fe0fbe9d
 SHA512:
-  metadata.gz: ceb38b4a6c827b0d8a7b09e0c0f86e9050e49dce54504cf5075d2d2da5fb9fe99186c8e9aa3403a14b61d5d6fa831e86a43886279dea8e20efd1c818e119d1f0
-  data.tar.gz: f53b20c6848b4d7cc825a18819ace61ebade1238706dbd125e76318eeb2dd1e4abbc6dca2d9872accb0069df8ac9edb16762c45ea7bc9a8293b95452d36102a6
+  metadata.gz: 78459e2694a2c1f97357307d550df8c9920b18be785b1c28d712b8d61c074ba4326c867b107b62985030fac412805c548858ee086f13802dec13b01e75c10f9c
+  data.tar.gz: 0a7ccd8153cda7309f70fbffb2fc2fe7f2595194ddf4688bcc13d28c86418fbe0f23322f5c47a2fba7b4aca0832e95b877747158bd17ad1da33a634bbc3eb529

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 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.2

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,15 +17,15 @@ 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:)
+    def member_to_human(member,side: ,format:, daily: false)
       high = side == :upper
-      "#{member[:datetime].strftime("%a, %Y-%m-%d %I:%M%p")
+      "#{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"
@@ -37,14 +37,32 @@ module Cotcube
     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: false, notice: nil)
+      return if swap[:empty]
+      daily =  %i[ continuous daily ].include?(swap[:interval])
+      datetime_format = daily ? '%Y-%m-%d' : '%Y-%m-%d %H:%M'
+      high = swap[:side] == :high
+      ohlc = high ? :high : :low
+      if short
+        puts "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)
+            }#{format('%20s', (swap[:exceeded] ? "  XXX: #{swap[:exceeded].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
 
@@ -66,42 +84,95 @@ 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)
       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[: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, "Consistent 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
+      data.reject!{|swap| swap[:exceeded] and swap[:exceeded] < datetime } unless datetime.nil?
+      # remove exceedance information that is found 'later'
+      data.map{|swap| swap.delete(:exceeded) if swap[:exceeded] and swap[:exceeded] > datetime}
+      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
 
   end

data/lib/cotcube-level/tritangulate.rb

@@ -9,15 +9,18 @@ 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
+      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 +29,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 +37,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 )
@@ -100,13 +104,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 +118,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
@@ -174,7 +177,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 +218,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 +247,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 +262,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 +309,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 +318,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.2
 platform: ruby
 authors:
 - Benjamin L. Tischendorf
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-24 00:00:00.000000000 Z
+date: 2021-08-29 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'