cotcube-level 0.2.0 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1c9fc6eb075ccc486c29c13d9989e52b5e659330cba2b900bdd4f420d085bb8
-  data.tar.gz: 6303babcc58fd8def53c747174c0feaa669c848787c0c32eaa811e0f76aad61f
+  metadata.gz: '04184473172dd9ffd09c49a16bf6c2a724eb5cbef3f0f3d5423c44dea55f530f'
+  data.tar.gz: 75d1363041e3767a2f79c277a0d945fd830c1521df481194d8162c36b36044f2
 SHA512:
-  metadata.gz: a5bc9e406caecd100ad2aebaf5934f9c2b6f0b3c43dc51aa76b63575bb52bd77fec7b06f5b183801149f6b35fb367462261e93bb2c174ef8b10b29bb61ee2370
-  data.tar.gz: b1de063e02b133b76aea5ffe01b357fad9b9ed99461225cf8780b7cc592ea00bd043afef6d957a3a2f78db02e75291bfac775aa2c56c3cd36886378fbd7f7767
+  metadata.gz: 70875d4dd83cb114b62456866b7c8ddaaa9753890442b06d71d770bb6408994cadcf3a5cd12704d658e049ed2aba0cd14bdbf79ce9d25e462ff9453c785a5142
+  data.tar.gz: 34aa4547dab7a3b13c896db860bcb23d36c432a0c3480cadf2e8a542351316d92cbe10a321ff8b20da236556312da27e8bb53ac6f65a1d885b48ccbe270c41ef

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+## 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
+
+## 0.3.0 (August 24, 2021)
+  - removed tests, moving to cotcube-jobs
+  - all: added documentation
+  - triangulate: added continuous support and documentation
+  - eod_stencil: added support for continuous futures
+  - adapted tests to recent changes
+  - cotcube-level: included intraday_stencil
+  - intraday_stencil: added to repo
+  - eod_stencil: fixing minor typo
+  - triangulate: fixed indention
+  - stencil: slight changes, incl rename to EODStencil
+  - detect_slope: now returns all members, regardless of amount (i.e. check whether it is a valid swap will be done later)
+
 ## 0.2.0 (August 17, 2021)
   - cotcube-level: added new module_functions, added restrictive constants for intervals and swaptypes
   - adding new features to so-called 'test suite'

data/README.md

@@ -5,20 +5,20 @@ of the development process. All in the beginning was the wish to create an algor
 lines. So for like 2 year I was whirling my head on how to put an algorithmic ruler on a chart and rotate it until
 one or a set of trend lines are concise outpout. 
 
-As most hard do accomplish thing turn out to be much easier when you put them up side down, same happend to me in this
+As most hard to accomplish things turn out to be much easier when you put them up side down, same happened to me in this
 matter. I found rotating the ruler is too hard for, but instead transforming (shearing) the chart itself while keeping
 the ruler at its _level_ is much more eligible.
 
 The idea and the development of the algorithm had taken place within another Cotcube project named 'SwapSeeker'. At
-some point the SwapSeeker has become too complex so I decided to decouple the Level and the Stencil as independent
+some point the SwapSeeker has become too complex so I decided to decouple the Level and the Stencils as separate
 functional unit, that can be used on arbitrary time series.
 
 ### The shear mapping
 
 There is really no magic in it. The timeseries (or basically an interval of a timeseries) needs to be prepared to locate
 in Cartesian Quadrant I with fitting x==0 to y==0, and then a binary search on shearing angles determines the resulting 
-muiltitangent of which as the origin ('now') one point already is given. As limitation only shearing between 0 and 90
-deg is supported. 
+muiltitangent of which the origin ('now') as one point already is given. One limitation applies: Only shearing between
+0 and 90 degrees is supported. 
 
 The result contains 
 
@@ -28,17 +28,25 @@ to happen if _deg -> 0_.
 - the origin and two or more points residing on the same level--what is the desired result showing mathematical accuracy where 
 human eye cannot detect it in time. 
 
+### Tritangulation
+
+The 'tri' is about that to find an artificially supported slope (i.e. a swap) at least 3 points 
+have to reside on it. It is leaned to triangulate, but instead of working with angles we are working with tangents here.
+
+Shear mapping and slope detection might find a slope meeting the requirements. But in tritangulate, near misses are
+considered and added as members. 
+
 ### The stencil
 
 The shearing transformation is based on _x_ and _y_ values, where y obviously are the values of the series while _x_
 refers to the time. It turned out a much bigger challenge to create an expedient mapping from DateTime to Integer,
 where, as you foresee, 'now' should result in _x.zero?_. 
 
-## Usage
+## Usage (pure template text)
 
 TODO: Write usage instructions here
 
-## Development
+## Development (pure template text)
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.4

data/cotcube-level.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['donkeybridge@jtown.eu']
 
   spec.summary       = 'A gem to shear a time series '
-  spec.description   = 'A gem to shear a time series, basically serving as a yet unssen class of indicators.'
+  spec.description   = 'A gem to shear a time series, basically serving as a yet unseen class of indicators.'
 
   spec.homepage      = 'https://github.com/donkeybridge/' + spec.name
   spec.license       = 'BSD-3-Clause'

data/lib/cotcube-level/detect_slope.rb

@@ -1,117 +1,98 @@
 module Cotcube
   module Level
-    #
-      # TODO: add support for slopes not only exactly matching but also allow 'dip' of n x ticksize
-      def detect_slope(base:, max: 90, debug: false, format: '% 5.2f', calculus: false, ticksize: nil, max_dev: 200)
-        raise ArgumentError, "'0 < max < 90, but got '#{max}'" unless max.is_a? Numeric and 0 < max and max <= 90
-        #
-        # aiming for a shearing angle, all but those in a line below the abscissa
-        #
-        # doing a binary search starting at part = 45 degrees
-        # on each iteration,
-        #   part is halved and added or substracted based on current success
-        #   if more than the mandatory result is found, all negative results are removed and degrees are increased by part
-        #
-        raise ArgumentError, 'detect_slope needs param Array :base' unless base.is_a? Array
-
-        # from given base, choose non-negative stencil containing values
-        old_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }
+    def detect_slope(base:, max: 90, debug: false, format: '% 5.2f', calculus: false, ticksize: nil, max_dev: 200)
+      raise ArgumentError, "'0 < max < 90, but got '#{max}'" unless max.is_a? Numeric and 0 < max and max <= 90
+      #
+      # this method processes a 'well prepared' stencil in a way, that :y values are sheared around stencil.zero,
+      #     resulting to a temporary :yy value for each point. this process is iterated until no more :yy
+      #     values are above the abscissa ( yy > 0 ) but at least one other values is on (yy == 0)
+      #
+      # the entire process initially aimed to find slopes that contain 3 or more members. the current version 
+      #     is confident with 2 members--or even one member, which results in an even slope.
+      #
+      # it works by running a binary search, whereon each iteration,
+      #   - :part is halved and added or substracted based on current success
+      #   - if more than the mandatory result is found, all negative results are removed and degrees are increased by part
+      #   - if no results are found, the process is repeated with the same current base after degrees are decreased by part
+      #
+      raise ArgumentError, 'detect_slope needs param Array :base' unless base.is_a? Array
 
-        # some debug output
-        old_base.each {|x| p x} if old_base.size < 50 and debug
+      # from given base, choose non-negative stencil containing values
+      old_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }
 
-        # set initial shearing angle if not given as param
-        deg ||= -max / 2.0 
+      # set initial shearing angle if not given as param. This is a prepared functionality, that is not yet used.
+      # when implemented to use in tritangulate, it would speed up the binary search process, but initial part 
+      # has to be set in a different way
+      deg ||= -max / 2.0
 
-        # create first sheering. please note how selection working with d[:yy]
-        new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 } #-ticksize }
+      # create first shearing. please note how selection works with d[:yy]
+      new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 }
 
-        # debug output
-        puts "Iterating slope:\t#{format '% 7.5f',deg
+      # debug output
+      puts "Iterating slope:\t#{format '% 7.5f',deg
                            }\t\t#{new_base.size
                            } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
                                                                     } | #{format format,f[:y]
                                                                     } | #{format format,f[:yy]}'"}.join(" || ") }" if debug
-        # set initial part to deg
-        part = deg.abs
-        #
-        # the loop, that runs until either
-        #   - only two points are left on the slope
-        #   - the slope has even angle
-        #   - several points are on the slope in quite a good approximation ('round(7)')
-        #
-        until deg.round(PRECISION).zero? || part.round(PRECISION).zero? ||
-            ((new_base.size >= 2) && (new_base.map { |f| f[:yy].round(PRECISION).zero? }.uniq.size == 1))
-
-          part /= 2.0
-          if new_base.size == 1
-            # the graph was sheared too far, reuse old_base
-            deg = deg + part
-          else
-            # the graph was sheared too short, continue with new base
-            deg = deg - part
-            old_base = new_base.dup unless deg.round(PRECISION).zero?
-          end
+      # set initial part to deg
+      part = deg.abs
+      #
+      # the loop, that runs until either
+      #   - only two points are left on the slope
+      #   - the slope has even angle
+      #   - several points are found on the slope in quite a good approximation ('round(PRECISION)')
+      #
+      until deg.round(PRECISION).zero? || part.round(PRECISION).zero? ||
+          ((new_base.size >= 2) && (new_base.map { |f| f[:yy].round(PRECISION / 2).zero? }.uniq.size == 1))
 
-          # the actual sheering operation
-          # note that this basically maps old_base with yy = y + (dx||x * tan(deg) )
-          #
-          new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 } #-ticksize }
-          new_base.last[:dx] = 0.0 
-          if debug
-            print " #{format '% 8.5f',deg}"
-            puts "Iterating slope:\t#{format '% 8.5f',deg
-                                 }\t#{new_base.size
-                               } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
-                                                                     } | #{format '%4.5f', part
-                                                                     } | #{format format,f[:y]
-                                                                     } | #{format format,f[:yy]}'"}.join(" || ") }"
-          end
+        part /= 2.0
+        if new_base.size == 1
+          # the graph was sheared too far, reuse old_base
+          deg += part
+        else
+          # the graph was sheared too short, continue with new base
+          deg -= part
+          old_base = new_base.dup unless deg.round(PRECISION).zero?
         end
-        puts ' done.' if debug
 
-        ### Sheering ends here
+        # the actual shearing operation
+        # this basically maps old_base with yy = y + (dx||x * tan(deg) )
+        #
+        new_base = shear_to_deg(base: old_base, deg: deg).select { |d| d[:yy] >= 0 }
+        new_base.last[:dx] = 0.0
 
-        # define the approximited result as (also) 0.0
-        new_base.each{|x| x[:yy] = 0.0}
-        if debug
-          puts "RESULT: #{deg} #{deg2rad(deg)}"
-          new_base.each {|f| puts "\t#{f.inspect}" }
-        end
-        # there is speacial treatment for even slopes
-        if deg.round(PRECISION).zero?
-          #puts "found even slope"
-          # this is intentionally voided as evenness is calculated somewhere else
-          # even_base = base.dup.select{|b| b[:x] >= 0 and not b[:y].nil? }[-2..-1].map{|x| x.dup}
-          # last_barrier is the last bar, that exceeds
-          #binding.irb
-          #last_barrier = even_base.select{|bar| (bar[:y] - even_base.last[:y]).abs > evenness * ticksize}.last
-          #even_base.select!{|bar| (bar[:y] - even_base.last[:y]).abs <= evenness * ticksize}
-          # could be, that no last barrier exists, when there is a top or bottom plateau
-          #even_base.select!{|bar| bar[:x] < last_barrier[:x]} unless last_barrier.nil?
-          # TODO
-          return { deg: 0,  slope: 0, members: [] } #, members: even_base.map { |x| xx = x.dup; %i[y yy].map { |z|  xx[z]=nil }; xx } })
+        # debug output is reduced by appr. 70%
+        if debug and Random.rand < 0.3
+          print " #{format '% 18.15f',deg}\t"
+          puts "Iterating slope:\t#{format '% 18.10f',deg
+                               }\t#{new_base.size
+                             } || #{new_base.values_at(*[0]).map{|f| "'#{f[:x]
+                                                                   } | #{format '%4.5f', part
+                                                                   } | #{format format,f[:y]
+                                                          } | #{format format,f[:yy]}'"}.join(" || ") }"
         end
+      end
+      ### Sheering ends here
 
+      # define the approximited result as (also) 0.0
+      new_base.each{|x| x[:yy] = 0.0}
 
-        #####################################################################################
-        # Calculate the slope bsaed on the angle that resulted above
-        #     y = m x + n -->
-        #                     m = delta-y / delta-x
-        #                     n = y0 - m * x0
-        #
-        slope     = (new_base.first[:y] - new_base.last[:y]) / (
-                        (new_base.first[:dx].nil? ? new_base.first[:x] : new_base.first[:dx]).to_f - 
-                        (new_base. last[:dx].nil? ? new_base. last[:x] : new_base. last[:dx]).to_f 
-                    )
-        # the result
-        {
-          deg:        deg,
-          slope:      slope,
-          members:   new_base.map { |x| x.dup }
-        }
-      end
+      #####################################################################################
+      # Calculate the slope based on the angle that resulted above
+      #     y = m x + n -->
+      #                     m = delta-y / delta-x
+      #                     n = y0 - m * x0
+      #
+      slope     = deg.zero? ? 0 : (new_base.first[:y] - new_base.last[:y]) / (
+        (new_base.first[:dx].nil? ? new_base.first[:x] : new_base.first[:dx]).to_f -
+        (new_base. last[:dx].nil? ? new_base. last[:x] : new_base. last[:dx]).to_f
+      )
+      # the result
+      {
+        deg:       deg,
+        slope:     slope,
+        members:   new_base.map { |x| x.dup }
+      }
+    end
   end
 end
-
-

data/lib/cotcube-level/{stencil.rb → eod_stencil.rb}

@@ -3,7 +3,7 @@
 module Cotcube
   module Level
 
-    class Stencil
+    class EOD_Stencil
       attr_accessor :base
       attr_reader   :interval
 
@@ -43,21 +43,16 @@ module Cotcube
         range: nil,                 # used to shrink the stencil size, accepts String or Date
         interval:,
         swap_type:,
-        ranges: nil,                # currently not used, prepared to be used in connection intraday
-        contract: nil,
         date: nil,
         debug: false,
         version: nil,               # when referring to a specicic version of the stencil
-        timezone: CHICAGO,
-        stencil: nil,               # instead of loading, use this data
-        #config: init,
-        warnings: true
+        timezone: Cotcube::Helpers::CHICAGO,
+        stencil: nil,               # instead of preparing, use this one if set
+        warnings: true              # be more quiet
       )
         @debug     = debug
-        @interval  = interval
+        @interval  = interval == :continuous ? :daily : interval
         @swap_type = swap_type
-        @swaps     = []
-        @contract  = contract
         @warnings = warnings
         step =  case @interval
                 when :hours, :hour; 1.hour
@@ -81,14 +76,14 @@ module Cotcube
                          swap_type
                        end
           # TODO: Check / warn / raise whether stencil (if provided) is a proper data type
-          raise ArgumentError, "Stencil should be nil or Array" unless [NilClass, Array].include? stencil.class
+          raise ArgumentError, "EOD_Stencil should be nil or Array" unless [NilClass, Array].include? stencil.class
           raise ArgumentError, "Each stencil members should contain at least :datetime and :x" unless stencil.nil? or
             stencil.map{|x| ([:datetime, :x] - x.keys).empty? and [ActiveSupport::TimeWithZone, Day].include?( x[:datetime] ) and x[:x].is_a?(Integer)}.reduce(:&)
 
-          base = stencil || Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version)
+          base = stencil || EOD_Stencil.provide_raw_stencil(type: stencil_type, interval: :daily, version: version)
 
-          # fast forward to prev trading day
-          date = CHICAGO.parse(date) unless [NilClass, Date, ActiveSupport::TimeWithZone].include? date.class
+          # fast rewind to previous trading day
+          date = timezone.parse(date) unless [NilClass, Date, ActiveSupport::TimeWithZone].include? date.class
           @date = date || Date.today
           best_match = base.select{|x| x[:datetime].to_date <= @date}.last[:datetime]
           @date  = best_match
@@ -106,12 +101,11 @@ module Cotcube
       end
 
       def dup
-        Stencil.new(
+        EOD_Stencil.new(
           debug:      @debug,
           interval:   @interval,
           swap_type:  @swap_type,
           date:       @date,
-          contract:   @contract,
           stencil:    @base.map{|x| x.dup}
         )
       end
@@ -142,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