ib-technical-analysis 0.2

data/bin/history.irb

@@ -0,0 +1,186 @@
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit#
+exit
+exit
+exit
+exit
+exit
+exit
+q
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+exit
+ATS.keys
+ATS.first
+p ATS.first
+p ATS.first
+puts ATS.first
+puts ATS.first.result
+puts ATS.first
+irb ATS.first
+@momentum
+methods
+@momentum
+exit
+puts ATS.first
+puts ATS.first.result
+p ATS.first
+p ATS.first.result
+p ATS.first..call :result
+p= ATS.first
+p
+purs p.result
+p= ATS[:"mini-dax"]
+puts p.result
+z=  const_set
+Base
+Base.const_set 'G'
+Base.const_set 'G', 6
+G
+z= Base.const_set 'G', 6
+z
+IB::Base::G
+z= IB.const_set 'GU', 6
+GU
+z= 'jleor'
+z.capitalize
+exit
+Dax
+Russel
+exit
+ATS.keys
+ATS[:dax]
+puts Russel.result
+puts Russell.result
+puts Russell.result[:result]
+puts Russell.result.map{|y| y[:result]}
+puts dax.result.map{|y| y[:result]}
+puts Dax.result.map{|y| y[:result]}
+print Dax.result.map{|y| y[:result]}
+print Dax.result.map{|y| y[:result].to_d}
+print Dax.result.map{|y| y[:result].to_f}
+print Russell.result.map{|y| y[:result].to_f}
+exit
+exit
+Dax.result
+puts Dax.result
+exit
+puts Dax.result
+puts Dax.result.result
+puts Dax.result
+print  Dax.result.result
+print  Dax.result.result.to_i
+print  Russell.result.result.to_i
+exti
+extit
+exit
+print  Dax.raw_data.result.to_i
+print  Dax.contract
+print  exit
+print  Dax.raw_data.result.to_i
+print  Dax.contract
+print  Dax.current_price_signal
+print  Dax.current_price_signal
+  Dax.current_price_signal
+exit
+print  Dax.current_price_signal
+  Dax.current_price_signal
+print  Dax.contract
+Dax.contract
+Dax.contract ; nil
+irb Dax
+@contract
+exit
+Dax.contract.to_human
+Dax.contract.to_human
+exit
+exit
+IB::BAR_SIZES
+IB::BAR_SIZES.keys
+exit
+Dax.contract.to_human
+Dax.raw_data.first
+exit
+i =  IB::Bar.new
+i.methods
+require 'technical-analysis'
+z.capitalize
+z= 'jleor'
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+zz= z.eod( duration: '50 D').each
+zz= z.calculate( :ema, period: 15 , use: :close )
+require 'ib-technical-analysis'
+TechnicalAnalysis::Momentum::Lane
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+exit
+exit
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz.close
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz.close
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+ indicator = TechnicalAnalysis::MovingAverage::KaMA.new period: 30, fast: 5, slow: 15, data: zz
+zz.first
+zz.first.pivot
+exit
+exit
+exit
+Dax.result
+Russell
+exit
+Dax
+Dax
+Dax.result
+Dax.raw_data.result
+Dax.raw_data.result.to_i
+exit
+z =  Symbols::Futures.mini_dax
+zz= z.eod duration: '50 D'
+Symbols::Stocks.all
+z= Symbols::Stocks.msft
+zz= z.eod duration: '50 D'
+z.close
+zz.close
+Symbols::Forex.all
+ IB::BAR_SIZES
+ IB::BAR_SIZES.key(hour)
+ IB::BAR_SIZES.key(:hour)
+ IB::BAR_SIZES.keys
+ IB::BAR_SIZES.values
+exit
+exit
+TradingSystem::Base
+exit

data/ib-technical-analysis.gemspec

@@ -0,0 +1,38 @@
+require_relative 'lib/technical_analysis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ib-technical-analysis"
+  spec.version       = TechnicalAnalysis::VERSION
+  spec.authors       = ["Hartmut Bischoff"]
+  spec.email         = ["topofocus@gmail.com"]
+
+  spec.summary       = %q{.Tools to perform technical analysis on financial data .}
+  spec.homepage      = "https://ib-ruby.github.io/ib-doc/"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+#  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.cm/ib-ruby/ib-technical-analysis"
+  spec.metadata["changelog_uri"] = "https://github.cm/ib-ruby/ib-technical-analysis/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('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+
+  spec.add_dependency "ib-api"
+  spec.add_dependency "ib-extensions"
+	spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'rspec-collection_matchers'
+  spec.add_development_dependency 'rspec-its' 
+
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+end

data/lib/calculation_helpers.rb

@@ -0,0 +1,149 @@
+require 'dry/core/class_attributes'
+
+module TechnicalAnalysis
+  module BarCalculation
+
+    def true_range previous_close
+      [
+        (high - low),
+        (high - previous_close).abs,
+        (low - previous_close).abs
+      ].max
+    end
+
+    def typical_price
+      ( high + low + close ) / 3.0
+    end
+  end
+
+
+
+  module MovingAverage 
+    EMA = Struct.new :time, :value
+    WMA = Struct.new :time, :value
+
+
+    # Calculates the exponential moving average (EMA) for the data over the given period
+    # https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+    #
+    #
+    # z = Symbols::Futures.mini_dax.eod( duration: '30 d').each
+    # e= nil
+    # ema= z.map{|y| e= TechnicalAnalysis::MovingAverage.ema( y.close, z.map(&:close), 30, e ) }
+    # 
+    # or
+    #
+    # EMA =  Struct.new :time, :ema
+    # e = nil
+    # ema = z.map do |y|
+    #    EMA.new y.time, 
+    #            e = TechnicalAnalysis::MovingAverage.ema y.close, z.map(&:close), 30, e
+    # end           
+    # 
+
+    def self.ema current_value, data, period, prev_ema
+      if prev_ema.nil?
+        data.sum / data.size.to_f # Average
+      else
+        (current_value - prev_ema) * (2.0 / (period + 1.0)) + prev_ema
+      end
+    end
+
+    # Calculates the weighted moving average
+    #
+    # Parameter is the data-array. 
+    #
+    # Takes an optional Block. Specify a method name that returns  the data item
+    #
+    # z = Symbols::Futures.mini_dax.eod( duration: '30 d').each
+    # TechnicalAnalysis::ArrayCalculation.wma( z ){ :close }
+    #
+    def self.wma(data)
+      intermediate_values = []
+      data.each_with_index do |datum, i|
+        datum = datum.send yield  if block_given?
+        intermediate_values << datum * (i + 1) / (data.size * (data.size + 1) / 2).to_f
+      end
+      intermediate_values.sum
+    end
+  end
+end
+
+## reopen IB::Bar and include BarCalculation  ( as Mixin  )
+
+module IB
+  class Bar
+    include TechnicalAnalysis::BarCalculation
+  end
+    # z= Symbols::Futures.mini_dax.eod( duration: '30 d').each
+    #
+    # loop do
+    #  bar= z.next
+    # puts bar.time, z.peek.true_range(bar.close)
+    # end.
+
+    # z.rewind
+    #
+    # z.map{ |y| x.typical_price }
+    #
+end           # module
+
+module  TASupport
+  refine Enumerator do
+    #
+    # first include 
+    #   using TASupport
+    # in your script.
+    #
+    # After fetching stock-data from a file, a database or the broker  and 
+    # converting it into an Enumerator (simply using array.each)
+    # 
+    #   calculate
+    #
+    # is just performed on the object
+    #
+    # The result is returned as array of structs. 
+    #
+    # z = Symbols::Futures.mini_dax.eod( duration: '50 d').each
+    # z.calculate { :close }
+    #
+    # zz= z.calculate( :ema ){ :typical_price }
+    # 
+    # zz= z.calculate( :ema, period: 3 ) { :close } 
+    # zz.first
+    #  => #<struct TechnicalAnalysis::MovingAverage::EMA time=Wed, 10 Mar 2021, value=0.149441e5
+    def calculate indicator= :ema,  **params
+      struct =  TechnicalAnalysis::MovingAverage.send :const_get, indicator.to_s.upcase 
+      buffer, start = nil, []
+      choice = if block_given? 
+                 yield  
+               elsif peek.respond_to?(:time)
+                 :close
+               else
+                 nil
+               end
+      data = choice.nil? ? self.to_a : map{|y| y.send choice }
+      period = params[:period] || 30
+      calc_ema =  ->(item){ buffer= TechnicalAnalysis::MovingAverage.ema item, data, period, buffer  }
+
+      if peek.respond_to? :time 
+        map{ | d |
+          value = case indicator
+                  when :ema
+                    calc_ema[ d.send choice  ]
+                  when :wma
+                    TechnicalAnalysis::MovingAverage.wma start << d.send( choice )
+                  end
+          struct.new d.time , value
+        }#map
+      else
+        case indicator
+        when :ema
+          map{ | d |  calc_ema[  choice.nil? ?  d : d.send( choice ) ] }
+        when :wma
+          map{ |d| TechnicalAnalysis::MovingAverage.wma( start << choice.nil? ?  d : d.send( choice )  ) }
+        end # case
+      end   # branch    
+    end     # def
+  end       # refine
+end         # module

data/lib/ib/bar.rb

@@ -0,0 +1,23 @@
+module IB
+  class Bar
+    def true_range previous_close
+      [
+        (high - low),
+        (high - previous_close).abs,
+        (low - previous_close).abs
+      ].max
+    end
+
+    def typical_price
+      ( high + low + close ) / 3.0
+    end
+
+    def pivot 
+      { pp: p=( high + close + low ).to_f / 3 ,
+        r1: ( 2 * p ).to_f - low.to_f,
+        r2: p + ( high - low ).to_f,
+        s1:  ( 2 * p ).to_f - high.to_f,
+        s2: p - ( high - low ).to_f }
+    end
+  end
+end

data/lib/ta_support.rb

@@ -0,0 +1,157 @@
+
+module  TASupport
+  refine Enumerator do
+    #
+    # first include 
+    #   using TASupport
+    # in your script.
+    #
+    # After fetching stock-data from a file, a database or the broker  and 
+    # converting it into an Enumerator (simply using array.each)
+    # 
+    #   calculate
+    #
+    # is just performed on the object
+    #
+    # The result is returned as array of structs. 
+    #
+    # z = Symbols::Futures.mini_dax.eod( duration: '150 d').each
+    # z.calculate use: :close 
+    #
+    # zz= z.calculate :ema, use: :typical_price 
+    # 
+    # zz= z.calculate( :ema, period: 3, use: :close 
+    # zz.first
+    #  => #<struct TechnicalAnalysis::MovingAverage::EMA time=Wed, 10 Mar 2021, value=0.149441e5
+    #
+    # Input-data are converted to float and then applied to the indicator-calculations
+    #
+    # A block can be provided to execute commands after calculating each single indicator value
+    # This is provided to enable backtests on the data
+    #
+    # The block gets the input-data **and** the calculated indicator struct. 
+    #
+    # i.e.
+    # buffer=[]
+    # zz= z.calculate( :ema, use: :typical_price ) do | raw, struct | 
+    #    buffer << struct.value
+    #    buffer.shift if buffer.size >2
+    #    momentum_indicator =  (buffer.first - buffer.last) <=> 0
+    #    crossing = case momentum_indicator
+    #         when +1
+    #           buffer.first > raw.close && buffer.last < raw.close
+    #         when -1
+    #           buffer.first < raw.close && buffer.last > raw.close
+    #         end
+    #    buy_or_sell =  momentum_indicator == 1 ? "buy" : "sell"
+    #    puts "#{buy_or_sell}-Signal: EMA-Indicator-Crossing @ #{struct.time}" if crossing
+    # end
+    #
+    #
+    def calculate indicator= :ema,  **params
+      struct = if indicator.to_s[-2,2]=='ma'
+                 TechnicalAnalysis::MovingAverage.send :const_get, indicator.to_s.upcase 
+               elsif indicator.to_s[-2,2]=='si' || indicator== :lane
+                 TechnicalAnalysis::Momentum.send :const_get, indicator.to_s.upcase 
+               end
+      buffer, start, default_value = nil, [], nil
+      
+      ## strict-mode
+      strict_mode =  params[:strict] || false
+
+      choice = if params[:use].present? 
+                 params[:use]
+               elsif peek.respond_to?(:time)
+                 :close
+               else
+                 nil
+               end
+      ## fill in defaults
+      case indicator
+      when :ema, :wma, :sma, :rsi
+        period = params[:period] || 15
+      when :kama
+        period = params[:period] || 15
+        fast = params[:fast] || 2
+        slow= params[:slow] || 30
+      when :tsi
+        high = params[:high] || 25
+        low = params[:low] || 13
+      when :lane
+        period = params[:period] || 10
+        fast = params[:fast] || 3
+        slow= params[:slow] || 3
+
+      end 
+
+      # start (array of processed values) is updated in every iteration
+      # applies to indicators 
+      # kama
+      # sma
+      # wma
+      #
+      a =  peek
+      date_field = if a.respond_to? :time
+                     :time
+                   elsif a.respond_to? :date_time
+                     :date_time
+                   elsif a.respond_to? :date
+                     :date
+                   else
+                     nil
+                   end
+      indicator_method =  case indicator
+                          when :sma, :simple_ma
+                            TechnicalAnalysis::MovingAverage::SimpleMA.new period: period, strict: strict_mode
+                          when :ema, :exp_ma
+                            TechnicalAnalysis::MovingAverage::ExpMA.new period: period, strict: strict_mode
+                          when :wma 
+                            TechnicalAnalysis::MovingAverage::Wma.new period: period, strict: strict_mode
+                          when :kama
+                            TechnicalAnalysis::MovingAverage::KaMA.new period: period, strict: strict_mode,
+                               fast: fast, slow: slow
+                          when :rsi
+                            TechnicalAnalysis::Momentum::Rsi.new  period: period 
+                          when :tsi
+                            TechnicalAnalysis::Momentum::Tsi.new  low: low, high: high
+                          when :lane
+                            TechnicalAnalysis::Momentum::Lane.new  slow: slow, fast: fast, period: period,
+                              take: choice
+                          end
+      ## iterate across the enumerator and return the result of the calculations
+      map.with_index { | d, i |
+        # central point to convert to float
+        unless indicator == :lane
+          raw_data = if date_field.present? || choice.present?
+                     d.send(choice).to_f
+                   else
+                     d.to_f
+                   end
+          indicator_method.add_item(raw_data)
+        else
+          indicator_method.add_item(d)
+        end
+
+        next if indicator_method.current.nil? # creates a nil entry 
+        value = indicator_method.current      # return this value
+        ## data-format of the returned array-elements
+        result =  if date_field.present?
+                    struct.new d.send(date_field), value
+                  else
+                    value
+                  end
+        # expose the input-data and the calculated indicator to the block
+        yielder = yield( d, result)  if block_given?
+        yielder.nil? ?  result  : yielder   #  return the expression from the block  if present
+      }.compact     # map
+    end     # def
+  end
+end
+
+##  notes on Enumerators
+#-  z:= An Enumerator
+#-  z.size == z.count
+#-  z.entries == z.to_a
+#-  z.take n   returns an array of the first n elements
+#-  z.sum, if enumerator-objects define a "+" method
+#