cotcube-indicators 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf34a07745a24a8973103aad577a9a50ff0c51d8024110b1919a1cc8761a2ab2
+  data.tar.gz: 28e0479f8ee5d3b307b1734b7b1dc2daab0e63fcfaf83b683c2db860b8749bde
+SHA512:
+  metadata.gz: 6e8ac4bfd2c0c3b1c4a148ce8af941b3641ce3d607ceec42f717dcbad154808436fe6f455f52cd54c0d3dc65f1d847522b216969ded24d9edfb990d6ec76001b
+  data.tar.gz: 75313bd5ad890dc65b6733b4a71e391a1f6ad1e29fd4021fed5f5d990a60c3c47a798a853025d389d692a8ebc69b916f9184a314eca15c7d4235757a54eb451d

data/.gitignore

@@ -0,0 +1,15 @@
+Gemfile.lock
+vendors/
+.idea/
+.bundle/
+Passengerfile.json
+passenger/
+bin/
+public/upload/
+public/css/
+public/full.raw
+public/full.raw.html
+compass/.sass-cache/
+stash/
+.rspec_status
+.yardoc

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 0.1.9 (December 02, 2020)
+  - worked through rubocops
+  - wrote according README.md
+  - added rspec dependency to gemspec
+  - added all indicators needed for current COTsignal calculations
+
+## 0.1.1 (December 01, 2020)
+
+

data/Gemfile

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

data/README.md

@@ -0,0 +1,103 @@
+# Cotcube::Indicators
+
+This gem containing the module 'Indicators' is part of the Cotcube suite. Its purpose
+is the application on indicators on a given time series. An example should help to
+understand how it works:
+
+```ruby
+series = 10.times.map {|i| Hash[x: i, y: ((i**2 + 2.0)/(4*i + 1)).round(2)] } 
+indicators = { 
+  first: Cotcube::Indicators.change(key: :y),
+  second: Cotcube::Indicators.change(key: :first, lookback: 2)
+}
+series.each  {|dataset| indicators.map{|key, lambada| dataset[key] = lambada.call(dataset).round(3) } }
+```
+
+This results in the following series (note that the applied function is arbitrary):
+
+| x | y | first | second |
+| --- | --- | --- | --- | 
+| 0 | 2.0  | 2.0  |  0.0 |
+| 1 | 0.6  | -1.4 | -1.4 |
+| 2 | 0.67 | 0.07 | -1.93 |
+| 3 | 0.85 | 0.18 | 1.58 |
+| 4 | 1.06 | 0.21 | 0.14 |
+| 5 | 1.29 | 0.23 | 0.05 | 
+| 6 | 1.52 | 0.23 | 0.02 |
+| 7 | 1.76 | 0.24 | 0.01 | 
+| 8 | 2.0  | 0.24 | 0.01 |
+| 9 | 2.24 | 0.24 | 0.0  | 
+
+where first displays the change of current `y` to its predecessor and second displays the change of `first` to its pre-predescessor. 
+
+## What is this 'Carrier' thingy
+
+It's just a super tiny helper class. Most indicators rely on a backward aggregation of data. For this purpose the Carrier 
+class maintains an array of given length for its indicator, FIFOing out-aged data.
+
+## Currently available indicators
+
+### calc
+
+This indicators is basically a helper. It allows arithmetical combination of 2 parameters (resp. calculation on one by omitting the other). The operation is passed as a block.
+
+### change
+
+Returns the difference (i.e. change) between `carrier.get.last` and `carrier.get.first`, where in most occasions `carrier.size` would be 2--hence comparing a current value with it's predecessor. 
+
+When passed a block, the indicator returns a value only when the block evaluates truthy, otherwise it returns 0'
+
+### index
+
+Returns an index-position of the current value within the carrier (i.e. 1.0 for being the highest, 0.0 for being the lowest value). 
+
+- When passed a block, the indicator returns a value only when the block evaluates truthy, otherwise it returns 0'
+- When passed `abs: true`, the absolute value is processed. 
+- When passed `reverse: true`, the result will be inverted by `1.0 - result`.
+
+### score
+
+Returns a score position if the current value within the carrier (i.e. 1 for being the highest, __carrier.size__ for being the lowest value). 
+
+- When passed `abs: true`, the absolute value is processed.
+- When passed `index: true`, the score is converted to an index, so score 1 matches 1.0 and __carrier.size__ matches 0.0.
+
+### true\_range 
+
+Returns the true range of the current value and it predescessor. Only works when the series contains [:high, :low. :close] or effective alternatives are promoted as parameters. __to get ATR combine this one with sma.__
+
+### sma, ema, rsi
+
+Returns the according classical indicator based on the provided `:key` and `:length`. 
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cotcube-indicators'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install cotcube-indicators
+
+## Development
+
+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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cotcube-indicators.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.9

data/cotcube-indicators.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cotcube-indicators'
+  spec.version       = File.read("#{__dir__}/VERSION")
+  spec.authors       = ['Benjamin L. Tischendorf']
+  spec.email         = ['donkeybridge@jtown.eu']
+
+  spec.summary       = 'Lambda based indicators, decoupled from legacy cotcube'
+  spec.description   = 'Lambda based indicators, decoupled from legacy cotcube'
+
+  spec.homepage      = 'https://github.com/donkeybridge/cotcube-indicators'
+  spec.license       = 'BSD-4-Clause'
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.7')
+
+  # spec.metadata['allowed_push_host'] = 'http://100.100.0.14:5001'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/donkeybridge/cotcube-indicators'
+  spec.metadata['changelog_uri'] = 'https://github.com/donkeybridege/cotcube-indicators/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_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~>3.6'
+  spec.add_development_dependency 'yard', '~>0.9'
+end

data/lib/cotcube-indicators.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubygems/package'
+require_relative 'cotcube-indicators/__carrier'
+require_relative 'cotcube-indicators/calc'
+require_relative 'cotcube-indicators/change'
+require_relative 'cotcube-indicators/index'
+require_relative 'cotcube-indicators/score'
+require_relative 'cotcube-indicators/ema'
+require_relative 'cotcube-indicators/sma'
+require_relative 'cotcube-indicators/rsi'
+require_relative 'cotcube-indicators/true_range'
+
+module Cotcube
+  module Indicators
+    module_function :calc, :change, :ema, :sma, :rsi, :true_range, :index, :score
+  end
+end

data/lib/cotcube-indicators/__carrier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    class Carrier
+      def initialize(length:)
+        raise ArgumentError, 'Need a length to be an integer' unless length.is_a? Integer
+
+        @length = length
+        @content = []
+      end
+
+      def <<(obj)
+        @content << obj
+        @content.shift if @content.length > @length
+        obj
+      end
+
+      def shift
+        @content.shift
+        # sending explicit return to avoid returning a value here
+        nil
+      end
+
+      def clear
+        @content = []
+      end
+
+      def get
+        @content
+      end
+
+      def size
+        @content.size
+      end
+      alias length size
+
+      def empty?
+        @content.empty?
+      end
+
+      def [](key)
+        @content.map { |x| x[key] }
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/calc.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def calc(a:, b:, &block)   # rubocop:disable Naming/MethodParameterName
+      lambda do |x|
+        block.call(x[a.to_sym], x[b.to_sym]).to_f
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/change.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    # returns the difference between the current value and the first available value in carrier.
+    #    if block given, the block is evaluated as conditional, using current and carrier.get.last.
+    #    if evaluation is false, carrier remains untouched and 0 is returned
+    def change(key:, lookback: 1, debug: false)
+      unless lookback.is_a?(Integer) && (lookback >= 1)
+        raise ArgumentError, 'invalid lookback period, need integer >= 1'
+      end
+
+      carrier = Cotcube::Indicators::Carrier.new(length: lookback + 1)
+
+      lambda do |x|
+        current = x[key.to_sym]
+        current = 0 unless current.is_a?(Numeric)
+        carrier << 0 if carrier.empty?
+        if debug
+          puts "comparing #{current} from #{key.to_sym} ... "\
+               "#{lookback} ... #{carrier.inspect} ... yield"\
+               " #{block_given? ? yield(carrier.get.last, current) : ''}"
+        end
+        if (not block_given?) || yield(carrier.get.last, current)  # rubocop:disable Style/GuardClause
+          carrier << current
+          ret = carrier.size < lookback + 1 ? 0 : (carrier.get.last - carrier.get.first)
+          return ret.to_f
+        else
+          return 0
+        end
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/ema.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    # the classic exponential moving average
+    def ema(key:, length:, smoothing:)
+      raise 'Missing parameter, need :length' if length.nil? || (not length.is_a? Integer)
+      raise 'Missing parameter, need :key'    if key.nil?
+
+      smoothing ||= (2 / (length - 1).to_f.round(2))
+      carrier = Carrier.new(length)
+      lambda do |x|
+        current = x[key.to_sym]
+        carrier << if carrier.empty?
+                     current * (smoothing / (1 + length))
+                   else
+                     current * (smoothing / (1 + length)) + carrier.get[-1] * (1 - (smoothing / (1 + length)))
+                   end
+        carrier.size < length ? -1.0 : carrier.get.last
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/index.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def index(key:, length:, debug: false, reverse: false, abs: false)
+      carrier = Carrier.new(length: length)
+
+      lambda do |x|
+        current = x[key.to_sym]
+        if debug
+          puts "comparing #{current} from #{key} ... "\
+               "#{length.nil? ? 0 : length} with yield #{block_given? ? yield(current) : ''}"
+        end
+        if (not block_given?) || yield(current)
+          current = current.abs if abs
+          puts "CURRENT: #{current}" if debug
+          carrier << current
+          puts "CARRIER: #{carrier.inspect}" if debug
+          divisor = carrier.get.max - carrier.get.min
+          puts "#{divisor} = #{carrier.get.max} - #{carrier.get.min}" if debug
+          return -1.0 if divisor.zero?
+
+          res = ((current - carrier.get.min) / divisor.to_f)
+          puts "RESULT: #{res}" if debug
+          return reverse ? (1 - res.to_f).round(3).to_f : res.round(3).to_f
+        else
+          carrier.shift
+          return 0
+        end
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/rsi.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def rsi(length:, key:, debug: false)
+      raise 'Missing parameter, need :key and :length options' if length.nil? || key.nil?
+
+      carrier = Carrier.new(length: length)
+
+      lambda do |x|
+        current = x[key.to_sym]
+        carrier << current
+        puts ". #{carrier.get} ." if debug
+        return 50.0 if carrier.length < length
+
+        u = carrier.get.select(&:positive?).map(&:abs).reduce(:+)
+        d = carrier.get.select(&:negative?).map(&:abs).reduce(:+)
+        d = d.nil? ? 10**-12 : d / length.to_f
+        u = u.nil? ? 10**-12 : u / length.to_f
+        return (100 - (100 / (1 + u / d))).to_f
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/score.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def score(key:, length:, abs: false, index: false)
+      # returns the position of current within carrier after sorting, i.e. if current has the highest rank it becomes
+      # 1, the lowest becomes :length to create comparable results for changing lengths, the score is put onto an
+      # index with top rank of 1 (1 - 0/:length)
+      carrier = Carrier.new(length: length)
+      lambda do |x|
+        current = x[key.to_sym]
+        current = current.abs if abs
+        if current.zero?
+          carrier.shift
+          return 0
+
+        end
+        carrier << current
+        score = carrier.get.sort.reverse.find_index(current)
+        score_index = (1 - score / length.to_f).round(3)
+        index ? score_index : (score + 1)
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/sma.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def sma(length:, key:)
+      raise 'Missing parameter, need :length and :value options' if opts[:length].nil? || opts[:value].nil?
+
+      carrier = Cotcube::Indicators::Carrier.new(length: length)
+      lambda do |x|
+        current = x[key.to_sym]
+        carrier << current
+        carrier.size < length ? 0.0 : (carrier.get.reduce(:+) / carrier.length).to_f
+      end
+    end
+  end
+end

data/lib/cotcube-indicators/true_range.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Cotcube
+  module Indicators
+    def true_range(high: :high, low: :low, close: :close)
+      carrier = Carrier.new(length: 1)
+      lambda do |current|
+        raise "Missing keys of #{high}, #{low}, #{close} in '#{current}'" unless [high, low, close] - current.keys == []
+
+        if carrier.empty?
+          carrier << current
+          return (current[high] - current[low]).to_f
+        end
+        last = carrier.get.first
+        carrier << current
+        ([current[high], last[close]].max - [current[low], last[close]].min).to_f
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: cotcube-indicators
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+platform: ruby
+authors:
+- Benjamin L. Tischendorf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-02 00:00:00.000000000 Z
+dependencies:
+- !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: Lambda based indicators, decoupled from legacy cotcube
+email:
+- donkeybridge@jtown.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- cotcube-indicators.gemspec
+- lib/cotcube-indicators.rb
+- lib/cotcube-indicators/__carrier.rb
+- lib/cotcube-indicators/calc.rb
+- lib/cotcube-indicators/change.rb
+- lib/cotcube-indicators/ema.rb
+- lib/cotcube-indicators/index.rb
+- lib/cotcube-indicators/rsi.rb
+- lib/cotcube-indicators/score.rb
+- lib/cotcube-indicators/sma.rb
+- lib/cotcube-indicators/true_range.rb
+homepage: https://github.com/donkeybridge/cotcube-indicators
+licenses:
+- BSD-4-Clause
+metadata:
+  homepage_uri: https://github.com/donkeybridge/cotcube-indicators
+  source_code_uri: https://github.com/donkeybridge/cotcube-indicators
+  changelog_uri: https://github.com/donkeybridege/cotcube-indicators/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: Lambda based indicators, decoupled from legacy cotcube
+test_files: []