ib-technical-analysis 0.2

data/lib/technical-analysis.rb

@@ -0,0 +1,11 @@
+require 'logging.rb'
+require 'ib/bar.rb'
+require 'technical_analysis/moving-average/base.rb'
+require 'technical_analysis/moving-average/simple-ma.rb'
+require 'technical_analysis/moving-average/weighted-ma.rb'
+require 'technical_analysis/moving-average/exp-ma.rb'
+require 'technical_analysis/moving-average/ka-ma.rb'
+require 'technical_analysis/momentum/tsi.rb'
+require 'technical_analysis/momentum/lane-stochastic.rb'
+require 'technical_analysis/momentum/rsi.rb'
+require 'ta_support'

data/lib/technical_analysis/bar_calculation.rb

@@ -0,0 +1,4 @@
+module TechnicalAnalysis
+  module BarCalculation
+
+end

data/lib/technical_analysis/lane.rb

@@ -0,0 +1,46 @@
+module TechnicalAnalysis
+
+  module Momentum 
+    RSI = Struct.new :time, :value
+    TSI = Struct.new :time, :value
+
+    #
+    # Calculates the true strength index (TSI) for the data over the given period
+    # https://en.wikipedia.org/wiki/True_strength_index
+
+    #
+    # 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.tsi current_value, tsi_source, low_period = 13, high_period = 25
+   
+      if current_value.present? 
+        tsi_source.push current_value 
+      else
+        current_value = tsi_source.last
+      end
+
+      momentum = tsi_source[-1] - tsi_source[-2]
+      
+      high_multiplier = (2.0 / (high_period + 1.0))
+      low_multiplier = (2.0 / (low_period + 1.0))
+
+      if prev_tsi.nil?
+        data.sum / data.size.to_f # Average
+      else
+        (current_value - prev_ema) * (2.0 / (period + 1.0)) + prev_ema
+      end
+    end
+  end
+end

data/lib/technical_analysis/momentum/lane-stochastic.rb

@@ -0,0 +1,105 @@
+module TechnicalAnalysis
+  module Momentum
+    LANE = Struct.new :time, :value
+
+
+=begin rdoc
+Defines the Lane-Stochastics
+           price   -     min(low)[period]
+  %k =   -----------------------------------------------
+          max(high)[period] -  min(low)[period]
+
+The Stochastics may depend on
+*  OHLC-Objects (IB::Bar).
+
+Then <em>"close"</em> is taken as default-value of the current candle.
+
+By specifiying the parameter <em>"take"</em> this can be customized.
+
+=end
+    class Lane
+      #       attr :oversold, true
+      #       attr :overbought, true
+
+      def initialize period: 5,  fast: 3, slow: 3, data: [], strict: true, take: :close
+        # note: strict is always true
+        raise "Periods must be greater then one" if  period <= 1
+        raise "fast must be smaller then slow" if  slow < fast 
+
+        @queue = []
+        @buffer = []
+        @take =  take
+        @smooth_2 = slow               # smooth-Const of StochasticsSlow
+        @smooth_1 = fast               # smooth-Const of StochasticsFast
+        @period = period               # period       of StochasticsLane
+        @stochastics_fast = TechnicalAnalysis::MovingAverage::ExpMA.new( period: @smooth_1, strict: true)
+        @stochastics_slow = TechnicalAnalysis::MovingAverage::ExpMA.new( period: @smooth_2, strict: true)
+        if !data.empty?
+          data.map{|d| add_item d }
+        end
+
+      end
+
+
+      # adds item, calculates the ema, puts value to the buffer and returns the result
+      def add_item  value
+        is_ohlc = nil
+        @queue << if value.is_a? IB::Bar
+                    is_ohlc = true 
+                    value
+        else
+          value.to_f
+        end
+
+        if @queue.size < @period
+          @buffer << nil
+        else
+          @queue.shift if @queue.size > @period
+          the_high = is_ohlc ? @queue.map(&:high).max : @queue.max 
+          the_low = is_ohlc ? @queue.map(&:low).min : @queue.min
+          # the value is :close by default. But can be :wap, :typical_price aso. 
+          the_value = is_ohlc ?  value.send( @take ) : value
+          k = ( the_value - the_low )/ ( the_high - the_low )
+          @stochastics_fast.add_item k
+
+          out_1 = if @stochastics_fast.current.present?
+                    @stochastics_slow.add_item @stochastics_fast.current
+                    @stochastics_fast.current
+                  else
+                    nil
+                  end
+
+          #puts "momentum:  #{@emas[:low].current} <--> #{@emas[:low_abs].current}"
+          out_2 = if @stochastics_slow.current.present?   # warmup perioda is over
+                    @stochastics_slow.current
+                  else
+                    nil
+                  end
+        end
+        @buffer << { fast: out_1, slow: out_2 }
+
+        current  #  return the last buffer value
+      end
+
+      # returns the ema-buffer
+      def stochastics
+        @buffer
+      end
+
+      alias lane stochastics 
+
+      # returns the ema if the last computed item
+      def current
+        obj = @buffer.last
+        if obj.values.compact.empty?
+          nil
+        else
+          obj
+        end
+      end
+    end
+
+    # set alias for the class
+    LaneStochastic =  Lane
+  end
+end

data/lib/technical_analysis/momentum/rsi.rb

@@ -0,0 +1,76 @@
+module TechnicalAnalysis
+  module Momentum
+    RSI = Struct.new :time, :value
+
+    class Rsi
+=begin
+
+  
+The RSI is calulated by
+
+             ExpMA( Deltas of up-trending Periods )
+  RSI  =   ----------------------------------------------
+            ExpMA( Deltas of down-trending Periods )
+
+
+ If the average of Delta values is zero, then according to the equation, the RS value will approach infinitiy
+=end
+    
+      def initialize period: 15, data: [], strict: true
+        # strict is always true
+
+        raise "Periods must be greater then one" if period <= 1
+
+        @queue = []
+        @buffer = []
+        @period= period
+
+        @emas = [ TechnicalAnalysis::MovingAverage::ExpMA.new( period: period, strict: true ),
+                  TechnicalAnalysis::MovingAverage::ExpMA.new( period: period, strict: true  ) ]
+
+        if !data.empty?
+          data.map{|d| add_item d }
+        end
+      end
+
+      # adds item, calculates the ema, puts value to the buffer and returns the result
+      def add_item  value
+        @queue << value.to_f
+
+        up_or_down =  -> (previous, actual) do
+          if actual >= previous
+            [actual-previous,0]
+          else
+            [0,previous-actual]
+          end
+        end
+
+        if @queue.size < 2
+          @buffer << nil
+        else
+          # up-trend-data are added to @emas.first, downtrend-data to @emas.last
+          # the lambda up_and_down always returns positve data (or "0")
+
+          @emas.zip( up_or_down[ *@queue[-2,2] ] ).each { | exp_ma, item | exp_ma.add_item item }
+
+          if @emas.first.current.present?
+            @buffer <<  100 - ( 100 / (1 + ( @emas.first.current / @emas.last.current rescue 100 ) ) )
+          end
+
+          current   #  return the last buffer value
+        end
+      end
+
+      # returns the ema-buffer
+      def  momentum
+        @buffer
+      end
+
+      # returns the ema if the last computed item
+      def current
+        @buffer.last
+      end
+    end
+
+  end
+end

data/lib/technical_analysis/momentum/tsi.rb

@@ -0,0 +1,79 @@
+module TechnicalAnalysis
+  module Momentum
+    TSI = Struct.new :time, :value
+
+    class Tsi
+=begin
+                ExpMA(low) ( ExpMA(high ) prices  )
+  TSI  =   ----------------------------------------------
+            ExpMA(low) ( ExpMA(high ) prices.abs  )
+
+
+While the TSI output is bound between +1 and −1, most values fall between +0.25 and −0.25. 
+Blau suggests interpreting these values as overbought and oversold levels, respectively, 
+at which point a trader may anticipate a market turn. 
+
+Trend direction is indicated by the slope of the TSI; 
+a rising TSI suggests an up-trend in the market, and a falling TSI suggests a down-trend
+
+=end
+    
+      def initialize low: 13, high: 25, data: [], strict: true
+        # strict is always true
+
+        raise "Periods must be greater then one" if  low <= 1 || high <= 1
+        raise "high must be greater then low" if  low > high 
+
+        @queue = []
+        @buffer = []
+        @low= low
+        @high = high
+
+        @emas = { high:  TechnicalAnalysis::MovingAverage::ExpMA.new( period: high, strict: true ),
+                  low:       TechnicalAnalysis::MovingAverage::ExpMA.new( period: low, strict: true  ),
+                  high_abs:  TechnicalAnalysis::MovingAverage::ExpMA.new( period: high, strict: true  ),
+                  low_abs:   TechnicalAnalysis::MovingAverage::ExpMA.new(  period: low, strict: true )  }
+
+        if !data.empty?
+          data.map{|d| add_item d }
+        end
+      end
+
+      # adds item, calculates the ema, puts value to the buffer and returns the result
+      def add_item  value
+        @queue << value.to_f
+
+        if @queue.size < 2
+          @buffer << nil
+        else
+          momentum =  @queue.last - @queue[-2]
+          @emas[:high].add_item momentum
+          @emas[:high_abs].add_item momentum.abs
+
+          if @emas[:high].current.present?
+            @emas[:low].add_item @emas[:high].current
+            @emas[:low_abs].add_item @emas[:high_abs].current
+          end
+
+          #puts "momentum:  #{@emas[:low].current} <--> #{@emas[:low_abs].current}"
+          if @emas[:low].current.present?   # warmup perioda is over
+            @buffer << @emas[:low].current / @emas[:low_abs].current
+          end
+
+          current  #  return the last buffer value
+        end
+      end
+
+      # returns the ema-buffer
+      def momentum 
+        @buffer
+      end
+
+      # returns the ema if the last computed item
+      def current
+         @buffer.last
+      end
+    end
+
+  end
+end

data/lib/technical_analysis/moving-average/base.rb

@@ -0,0 +1,59 @@
+module TechnicalAnalysis
+  module MovingAverage
+
+
+
+    class  Base
+      def initialize period: 15,  data: [], strict: true
+
+        raise "Period must be greater then one" if  period <= 1
+        @period = period
+        @strict= strict
+        # queue for relevant data to process the calculation
+        @queue =  []
+        # buffer contains the calculated indicator values
+        @buffer = []
+      end
+
+      # adds item, calculates the ema, puts value to the buffer and returns the result
+      def add_item  value
+        @queue << value
+        @queue.shift if @queue.size > @period
+        if @buffer.empty?
+          @buffer=[value.to_f]
+        else
+          prev_ema = @buffer.last
+          current_value = value.to_f
+          @buffer << (current_value - prev_ema) * @smooth_constant + prev_ema
+        end
+       current  #  return the last buffer value
+      end
+
+      # returns the moving-average-buffer
+      def ma 
+        if @strict
+          @buffer.drop @period-1
+        else
+          @buffer
+        end
+      end
+
+
+      # returns the ema of the last computed item
+      def current 
+         if @strict && warmup?
+           nil
+         else
+           @buffer.last
+         end
+      end
+
+      private
+
+      def warmup?
+        @queue.size < @period
+      end
+    end
+
+  end
+end

data/lib/technical_analysis/moving-average/exp-ma.rb

@@ -0,0 +1,53 @@
+module TechnicalAnalysis
+  module MovingAverage
+    EMA = 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
+    #
+    # Takes a block which replaces the _smooth-constant_
+    #
+    #   z = Symbols::Futures.mini_dax.eod( duration: '90 d')
+    #   TechnicalAnalysis::MovingAverage::ExpMA.new( data=z.map(&:close))
+    #
+    # returns an array with the calculated moving-average data
+    #
+    #   ema = TechnicalAnalysis::MovingAverage::ExpMA.new( default_value = z.first[:close])
+    #   moving_average = z.map{|x| EMA.new x.time,  ema.add_item(x.close)} 
+    #
+    # returns an array of EMA-Objects
+    # 
+
+    class ExpMA  < Base
+      def initialize period: 15, data: [], strict: true
+        super
+
+        @smooth_constant = if block_given? 
+                             yield period
+                           else
+                             (2.0 / (period + 1.0))
+                           end
+        if !data.empty?
+          data.map{|d| add_item d }
+        end
+      end
+
+      # adds item, calculates the ema, puts value to the buffer and returns the result
+      def add_item  value
+        @queue << value
+        @queue.shift if @queue.size > @period
+        if @buffer.empty?
+          @buffer=[value.to_f]
+        else
+          prev_ema = @buffer.last
+          current_value = value.to_f
+          @buffer << (current_value - prev_ema) * @smooth_constant + prev_ema
+        end
+       current  #  return the last buffer value
+      end
+
+    end
+
+  end
+end

data/lib/technical_analysis/moving-average/ka-ma.rb

@@ -0,0 +1,90 @@
+module TechnicalAnalysis
+  module MovingAverage
+    KAMA = 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
+    #
+    # Takes a block which replaces the _smooth-constant_
+    #
+    #   z = Symbols::Futures.mini_dax.eod( duration: '90 d')
+    #   TechnicalAnalysis::MovingAverage::ExpMA.new( data=z.map(&:close))
+    #
+    # returns an array with the calculated moving-average data
+    #
+    #   ema = TechnicalAnalysis::MovingAverage::ExpMA.new( default_value = z.first[:close])
+    #   moving_average = z.map{|x| EMA.new x.time,  ema.add_item(x.close)} 
+    #
+    # returns an array of EMA-Objects
+    # 
+
+    class KaMA
+      def initialize period: 10, fast: 2, slow: 30, data: []
+
+        raise "Period must be greater then one" if  period <= 1
+
+        @smoothConst_fast = 2 / (fast +1).to_f
+        @smoothConst_slow = 2 / (slow +1).to_f
+
+        @period = period
+        @queue = []
+        @buffer = []
+        
+        if !data.empty?
+          data.map{|d| add_item d }
+        end
+      end
+
+      # adds item, calculates the kama, puts value to the buffer and returns the result
+      def add_item  value
+        begin
+        @queue << value.to_f
+      rescue NoMethodError => e
+        puts "add item only supports single values. Using the :close method"
+        @queue << value.send(:close) || value
+        end
+        if @queue.size < @period
+          @buffer = [ @queue.sum / @queue.size ]  # fill buffer with  average
+        else
+          @queue.shift if @queue.size > @period
+          @buffer << calculate
+        end
+        current #  return the last buffer value
+      end
+
+      # returns the kama-buffer
+      def kaema
+        @buffer
+      end
+
+      # returns the kama of the last computed item
+      def current
+         @buffer.last
+      end
+
+      private
+      def calculate
+        # define the Effiency Ratio to be used by the "kaufmans Adaptive Moving Average" :  kama 
+        # ER is calculated by dividing the absolute difference between the
+        # current price and the price at the beginning of the period by the sum
+        # of the absolute difference between each pair of closes during the
+        # period.
+        #				| x(t) - x(t-n) |
+        # er = ----------------------------
+        #			 sum | x(i) - x(i-1) |
+
+        er= (@queue.first - @queue.last).abs /
+            (1..@queue.size-1).map{|x| (@queue[x] - @queue[x-1]).abs }.sum # rescue 1
+
+        alpha = (er * ( @smoothConst_fast - @smoothConst_slow ) + @smoothConst_slow )**2
+        prev_kama = @buffer.last
+        current_value = @queue.last
+
+        @buffer.last + alpha * (current_value - prev_kama)
+      end
+
+    end
+
+  end
+end