unageanu-jiji 1.1.4 → 1.2.1

data/ChangeLog

@@ -1,7 +1,30 @@
 
+2009-8-15 1.2.0
+    * エージェントエディタを一新
+        - 複数のエージェントや共有ライブラリをタブで同時に編集できるようになりました。
+        - エージェントや共有ライブラリをディレクトリで分類できるようになりました。
+
+    * 標準ライブラリの追加
+      標準添付の共有ライブラリとして、以下を追加。
+        - 移動平均などの各種シグナル算出クラス
+        - ロスカットやトレーリングストップを容易に実現するPositionManager
+        - クロスアップ、クロスダウンを判定するためのユーティリティ
+
+    * バックテストの再実行機能を追加
+        - バックテストを1クリックで再実行できるようになりました。
+
+    * グラフ出力の不具合修正
+        - エージェントを削除するとそのグラフも表示できなくなる問題を改修しました。
+        - この変更でリアルトレードでは古いグラフが蓄積されていくようになったため、
+          不要なグラフを破棄する機能も追加しました。
+
+2009-8-8 1.1.4
+    * クリック証券デモ取引Webサービスの提供終了にあわせて、デモ取引接続プラグインを
+      無効化
+
 2009-7-5 1.1.3
     * クリック証券のデモ取引に接続する場合に、設定でプロキシを空のまま確定すると
-    　接続エラーになる不具合を改修。
+      接続エラーになる不具合を改修。
 
 2009-6-29 1.1.2
     * クリック証券プラグインを標準添付

data/base/shared_lib/moving_average.rb

@@ -1,34 +1,35 @@
-# 一定期間の移動平均を得る
-class MovingAverage
-  def initialize( range=25 )
-    @rates = [] # レートを記録するバッファ
-    @range = range
-  end
-
-  def next_rate( rate )
-    # バッファのデータを更新
-    @rates.push rate
-    @rates.shift if @rates.length > @range
-    
-    # バッファサイズが十分でなければ、nilを返す。
-    return nil if @rates.length != @range
-    
-    # 移動平均を算出
-    return MovingAverage.get_moving_average(@rates)
-  end
-
-  # 前の結果(引数で指定した件数だけ記録。)
-  attr :prev, true
-  
-private
-  # 移動平均値を計算する。 
-  def self.get_moving_average( rates )
-    total = 0
-    rates.each {|s|
-      total += s.end
-      total += s.max
-      total += s.min
-    }
-    return total / ( rates.length * 3 )
-  end  
+
+# 一定期間の移動平均を得る
+class MovingAverage
+  def initialize( range=25 )
+    @rates = [] # レートを記録するバッファ
+    @range = range
+  end
+
+  def next_rate( rate )
+    # バッファのデータを更新
+    @rates.push rate
+    @rates.shift if @rates.length > @range
+    
+    # バッファサイズが十分でなければ、nilを返す。
+    return nil if @rates.length != @range
+    
+    # 移動平均を算出
+    return MovingAverage.get_moving_average(@rates)
+  end
+
+  # 前の結果(引数で指定した件数だけ記録。)
+  attr :prev, true
+  
+private
+  # 移動平均値を計算する。 
+  def self.get_moving_average( rates )
+    total = 0
+    rates.each {|s|
+      total += s.end
+      total += s.max
+      total += s.min
+    }
+    return total / ( rates.length * 3 )
+  end  
 end

data/base/shared_lib/system/cross.rb

@@ -0,0 +1,76 @@
+
+#===交差状態を判定するユーティリティ
+#先行指標と遅行指標を受け取って、クロスアップ/クロスダウンを判定するユーティリティです。
+#
+# require 'cross'
+#
+# cross = Cross.new
+#
+# # 先行指標、遅行指標を受け取って状態を返す。
+# # :cross .. クロスアップ、クロスダウン状態かどうかを返す。
+# #             - クロスアップ(:up)
+# #             - クロスダウン(:down)
+# #             - どちらでもない(:none)
+# # :trend .. 現在の指標が上向きか下向きかを返す。
+# #           「先行指標 <=> 遅行指標」した値。
+# #           trend >= 1なら上向き、trned <= -1なら下向き
+# p cross.next_data( 100, 90 )  # {:trend=>1, :cross=>:none}
+# p cross.next_data( 110, 100 ) # {:trend=>1, :cross=>:none}
+# p cross.next_data( 100, 100 ) # {:trend=>0, :cross=>:none}
+# p cross.next_data( 90, 100 )  # {:trend=>-1, :cross=>:down}
+# p cross.next_data( 80, 90 )   # {:trend=>-1, :cross=>:none}
+# p cross.next_data( 90, 90 )   # {:trend=>0, :cross=>:none}
+# p cross.next_data( 100, 100 ) # {:trend=>0, :cross=>:none}
+# p cross.next_data( 110, 100 ) # {:trend=>1, :cross=>:up}
+# 
+class Cross
+
+  #コンストラクタ
+  def initialize
+    @cross_prev = nil
+    @cross = :none
+    @trend = 0
+  end
+
+  #===次の値を渡し状態を更新します。
+  #fast:: 先行指標
+  #lazy:: 遅行指標
+  def next_data( fast, lazy )
+    return unless fast && lazy
+    # 交差状態を算出
+    @trend = fast <=> lazy
+    if @cross_prev && @trend != @cross_prev && @trend != 0
+      @cross = @trend > @cross_prev ? :up : :down
+    else
+      @cross = :none
+    end
+    @cross_prev = @trend
+    return {:cross=>@cross,:trend=>@trend}
+  end
+
+  #===クロスアップ状態かどうか判定します。
+  #戻り値:: 「先行指標 < 遅行指標」 から 「先行指標 > 遅行指標」 になったらtrue
+  def cross_up?
+    @cross == :up
+  end
+  #===クロスダウン状態かどうか判定します。
+  #戻り値:: 「先行指標 > 遅行指標」 から 「先行指標 < 遅行指標」 になったらtrue
+  def cross_down?
+    @cross == :down
+  end
+  #===上昇トレンド中かどうか判定します。
+  #戻り値:: 「先行指標 > 遅行指標」 ならtrue
+  def up?
+    @trend > 0
+  end
+  #===下降トレンド中かどうか判定します。
+  #戻り値:: 「先行指標 < 遅行指標」 ならtrue
+  def down?
+    @trend < 0
+  end
+
+  #交差状態( :up, :down, :none )
+  attr_reader :cross
+  #トレンド ( 直近の falst <=> lazy 値。)
+  attr_reader :trend
+end

data/base/shared_lib/system/position_manager.rb

@@ -0,0 +1,160 @@
+
+#===ポジションマネージャ
+#以下の機能を提供するユーティリティクラスです。
+#-  条件にマッチするポジションを探す。
+#-  すべてのor条件にマッチするポジションを決済する。
+#-  指定したポジションを損切りorトレーリングストップで決済する。
+class PositionManager
+  include Enumerable
+  
+  #====コンストラクタ
+  #operator:: オペレータ
+  def initialize( operator )
+    raise "illegal argument." unless operator
+    @operator = operator
+    @marked = {}
+  end
+
+  #====ポジションを列挙します。
+  def each( &block )
+    @operator.positions.each_pair {|k,v|
+      yield v
+    }
+  end
+
+  #====条件にマッチするポジションを決済します。
+  #&block:: 決済するポジションを判定するブロック。JIJI::Positionが引数として渡され、trueが返された場合決済されます。
+  def commit_by
+    each {|p|
+      @operator.commit( p ) if yield p
+    }
+  end
+
+  #====すべてのポジションを決済します。
+  def commit_all
+    commit_by{|p| true }
+  end
+
+  #====現在保有しているポジションの損益合計を取得します。
+  #※決済済みポジションの損益は含まれません。
+  #戻り値:: 現在保有しているポジションの損益合計
+  def total_profit_or_loss
+    inject(0.0) {|t, p|
+      t += p.profit_or_loss
+    }
+  end
+
+  #====ポジションに損切りロジックを登録します。
+  #損切りロジックが登録されたポジションはcheckが実行される度に損益がチェックされ、
+  #PositionManager::StopStrategy.close?がtrueになれば決済されます。
+  #1つのポジションに対して複数のロジックを設定可能。いずれかのロジックがtrueを返せば損切りされます。
+  #position_id:: ポジションID
+  #stop_strategy:: 損切りルール(PositionManager::StopStrategy)
+  def register( position_id, stop_strategy )
+    @marked[position_id] ||= []
+    @marked[position_id] << stop_strategy
+  end
+
+  #====ポジションをロスカットの対象としてマークします。
+  #マークされたポジションはcheckが実行される度に損益がチェックされ、
+  #損失がdissipationで設定した値以下になっていれば決済されます。
+  #
+  #position_id:: ポジションID
+  #dissipation:: 許容しうる損失
+  def register_loss_cut( position_id, dissipation )
+    register(position_id,LossCut.new( dissipation ))
+  end
+
+  #====ポジションをトレーリングストップの対象としてマークします。
+  #マークされたポジションはcheckが実行される度に損益がチェックされ、
+  #「今までの最高損益-現在の損益」がdissipationで設定した値以下になっていれば決済されます。
+  #
+  #position_id:: ポジションID
+  #dissipation:: 許容しうる損失
+  def register_trailing_stop( position_id, dissipation )
+    register(position_id,TrailingStop.new( dissipation ))
+  end
+
+  #====ポジションに損切りロジックが登録されているかどうか評価します。
+  #position_id:: ポジションID
+  #return:: 損切りの対象であればtrue
+  def registered?( position_id )
+    @marked.key?(position_id)
+  end
+
+  #====ポジションに登録されている損切りロジックの一覧を取得します。
+  #position_id:: ポジションID
+  #return:: ポジションに登録されている損切りロジックの配列
+  def get_registered_strategy( position_id )
+    @marked[position_id] || []
+  end
+
+  #====ポジションに登録された損切りロジックを解除します。
+  #position_id:: ポジションID
+  #strategy:: 削除する損切りロジック
+  def unregister(position_id, strategy)
+    list = get_registered_strategy(position_id)
+    list.delete(strategy)
+  end
+
+  #====ポジションに登録された損切りロジックを全て解除します。
+  #position_id:: ポジションID
+  def unregister_all(position_id)
+    @marked.delete( position_id )
+  end
+
+
+  #====監視対象のポジションが閾値を越えていないかチェックし、必要があれば決済します。
+  #定期的に実行してください。
+  #戻り値:: 決済したポジションの配列
+  def check
+    commited = []
+    @marked.each_pair {|k,v|
+      p = @operator.positions[k]
+      if !p || p.state != JIJI::Position::STATE_START
+        @marked.delete p.position_id
+      else
+        v.each {|strategy|
+          next unless strategy.close?(p)
+          @operator.commit( p )
+          commited << p
+          unregister_all( p.position_id )
+          break
+        }
+      end
+    }
+    commited
+  end
+
+  #===手じまい戦略
+  module StopStrategy
+    #====決済すべきか評価する。
+    #position:: ポジション(JIJI::Position)
+    def close?(position)
+      return false
+    end
+  end
+  #===トレーリングストップ
+  class TrailingStop
+    include StopStrategy
+    def initialize( dissipation )
+      @dissipation=dissipation
+    end
+    def close?(position)
+      @max=0 if !@max
+      result = (@max - position.profit_or_loss)*-1 <= @dissipation
+      @max = [position.profit_or_loss, @max].max
+      return result
+    end
+  end
+  #===ロスカット
+  class LossCut
+    include StopStrategy
+    def initialize( dissipation )
+      @dissipation=dissipation
+    end
+    def close?(position)
+      position.profit_or_loss <= @dissipation
+    end
+  end
+end

data/base/shared_lib/system/signal.rb

@@ -0,0 +1,347 @@
+
+module Signal
+
+  #===一定期間のレートデータを元に値を算出するシグナルの基底クラス
+  class RangeSignal
+    include Signal
+    #====コンストラクタ
+    #range:: 集計期間
+    def initialize( range=25 )
+      @datas = [] # レートを記録するバッファ
+      @range = range
+    end
+    #====次のデータを受け取って指標を返します。
+    #data:: 次のデータ
+    #戻り値:: 指標。十分なデータが蓄積されていない場合nil
+    def next_data( data )
+      # バッファのデータを更新
+      @datas.push data
+      @datas.shift if @datas.length > @range
+
+      # バッファサイズが十分でなければ、nilを返す。
+      return nil if @datas.length != @range
+
+      # 算出
+      return calculate(@datas)
+    end
+    # 
+    def calculate(datas); end #:nodoc:
+     #集計期間
+     attr_reader :range
+  end
+
+  #===移動平均
+  class MovingAverage < RangeSignal
+    def calculate(datas) #:nodoc:
+      ma( datas )
+    end
+  end
+
+  #===加重移動平均
+  class WeightedMovingAverage < RangeSignal
+    def calculate(datas) #:nodoc:
+      wma( datas )
+    end
+  end
+
+  #===指数移動平均
+  class ExponentialMovingAverage < RangeSignal
+    #====コンストラクタ
+    #range:: 集計期間
+    #smoothing_coefficient:: 平滑化係数
+    def initialize( range=25, smoothing_coefficient=0.1 )
+      super(range)
+      @sc = smoothing_coefficient
+    end
+    def calculate(datas) #:nodoc:
+      ema( datas, @sc )
+    end
+  end
+
+  #===ボリンジャーバンド
+  class BollingerBands < RangeSignal
+    #====コンストラクタ
+    #range:: 集計期間
+    #pivot:: ピボット
+    def initialize( range=25, pivot=[0,1,2], &block )
+      super(range)
+      @pivot = pivot
+      @block = block
+    end
+    def calculate(datas) #:nodoc:
+      bollinger_bands( datas, @pivot, &@block )
+    end
+  end
+
+  #===傾き
+  class Momentum < RangeSignal
+    def calculate(datas) #:nodoc:
+      momentum( datas )
+    end
+  end
+
+  #===傾き(最小二乗法を利用)
+  class Vector < RangeSignal
+    def calculate(datas)
+      vector( datas )
+    end
+  end
+
+  #===MACD
+  class MACD < RangeSignal
+    #====コンストラクタ
+    #short_range:: 短期EMAの集計期間
+    #long_range:: 長期EMAの集計期間
+    #signal_range:: シグナルの集計期間
+    #smoothing_coefficient:: 平滑化係数
+    def initialize( short_range=12, long_range=26,
+        signal_range=9, smoothing_coefficient=0.1 )
+      raise "illegal arguments." if short_range > long_range
+      super(long_range)
+      @short_range = short_range
+      @smoothing_coefficient = smoothing_coefficient
+      @signal = ExponentialMovingAverage.new(
+        signal_range, smoothing_coefficient )
+    end
+    def next_data( data ) #:nodoc:
+      macd = super
+      return nil unless macd
+      signal = @signal.next_data( macd )
+      return nil unless signal
+      return { :macd=>macd, :signal=>signal }
+    end
+    def calculate(datas) #:nodoc:
+      macd( datas, @short_range, range, @smoothing_coefficient )
+    end
+  end
+
+  #===RSI
+  class RSI < RangeSignal
+    #====コンストラクタ
+    #range:: 集計期間
+    def initialize( range=14 )
+      super(range)
+    end
+    def calculate(datas) #:nodoc:
+      rsi( datas )
+    end
+  end
+
+  #===DMI
+  class DMI < RangeSignal
+    #====コンストラクタ
+    #range:: 集計期間
+    def initialize( range=14 )
+      super(range)
+      @dxs = []
+    end
+    def calculate(datas) #:nodoc:
+      dmi = dmi( datas )
+      return nil unless dmi
+      @dxs.push dmi[:dx]
+      @dxs.shift if @dxs.length > range
+      return nil if @dxs.length != range
+       dmi[:adx] = ma( @dxs )
+      return dmi
+    end
+  end
+
+  #===ROC
+  class ROC < RangeSignal
+    #====コンストラクタ
+    #range:: 集計期間
+    def initialize( range=14 )
+      super(range)
+    end
+    def calculate(datas) #:nodoc:
+      roc( datas )
+    end
+  end
+
+module_function
+
+  #===移動平均値を計算します。
+  #datas:: 値の配列。
+  #戻り値:: 移動平均値
+  def ma( datas )
+    total = datas.inject {|t,s|
+      t += s; t
+    }
+    return total / datas.length
+  end
+
+  #===加重移動平均値を計算します。
+  #datas:: 値の配列。
+  #戻り値:: 加重移動平均値
+  def wma( datas )
+    weight = 1
+    total = datas.inject(0.0) {|t,s|
+      t += s * weight
+      weight += 1
+      t
+    }
+    return total / ( datas.length * (datas.length+1)  /2 )
+  end
+
+  #===指数移動平均値を計算します。
+  #datas:: 値の配列。
+  #smoothing_coefficient:: 平滑化係数
+  #戻り値:: 加重移動平均値
+  def ema( datas, smoothing_coefficient=0.1 )
+    datas[1..-1].inject( datas[0] ) {|t,s|
+      t + smoothing_coefficient * (s - t)
+    }
+  end
+
+  #
+  #===ボリンジャーバンドを計算します。
+  #
+  # +2σ＝移動平均＋標準偏差×2
+  # +σ＝移動平均＋標準偏差
+  # -σ＝移動平均-標準偏差
+  # -2σ＝移動平均-標準偏差×2
+  # 標準偏差＝√((各値-値の期間中平均値)の2乗を期間分全部加えたもの)/ 期間
+  # (√は式全体にかかる)
+  #
+  #datas:: 値の配列
+  #pivot:: 標準偏差の倍数。初期値[0,1,2]
+  #block:: 移動平均を算出するロジック。指定がなければ移動平均を使う。
+  #戻り値:: ボリンジャーバンドの各値の配列。例)  [+2σ, +1σ, TP, -1σ, -2σ]
+  #
+  def bollinger_bands( datas, pivot=[0,1,2], &block )
+    ma = block_given? ? yield( datas ) : ma( datas )
+    total = datas.inject(0.0) {|t,s|
+      t+= ( s - ma ) ** 2
+      t
+    }
+    sd = Math.sqrt(total / datas.length)
+    res = []
+    pivot.each { |r|
+      res.unshift( ma + sd * r )
+      res.push( ma + sd * r * -1 ) if r != 0
+    }
+    return res
+  end
+
+  #===一定期間の値の傾きを計算します。
+  #datas::  値の配列
+  #戻り値:: 傾き。0より大きければ上向き。小さければ下向き。
+  def momentum( datas )
+      (datas.last - datas.first) / datas.length
+  end
+
+  #===最小二乗法で、一定期間の値の傾きを計算します。
+  #datas::  値の配列
+  #戻り値:: 傾き。0より大きければ上向き。小さければ下向き。
+  def vector( datas )
+    # 最小二乗法を使う。
+    total = {:x=>0.0,:y=>0.0,:xx=>0.0,:xy=>0.0,:yy=>0.0}
+    datas.each_index {|i|
+      total[:x] += i
+      total[:y] += datas[i]
+      total[:xx] += i*i
+      total[:xy] += i*datas[i]
+      total[:yy] += datas[i] * datas[i]
+    }
+    n = datas.length
+    d = total[:xy]
+    c = total[:y]
+    e = total[:x]
+    b = total[:xx]
+    return (n*d - c*e) / (n*b - e*e)
+  end
+
+  #===MACDを計算します。
+  #MACD = 短期(short_range日)の指数移動平均 - 長期(long_range日)の指数移動平均
+  #datas::  値の配列
+  #smoothing_coefficient:: 平滑化係数
+  #戻り値:: macd値
+  def macd( datas, short_range, long_range, smoothing_coefficient )
+    ema( datas[ short_range*-1 .. -1], smoothing_coefficient ) \
+      - ema( datas[ long_range*-1 .. -1], smoothing_coefficient )
+  end
+
+  #===RSIを計算します。
+  #RSI = n日間の値上がり幅合計 / (n日間の値上がり幅合計 + n日間の値下がり幅合計) * 100
+  #nとして、14や9を使うのが、一般的。30以下では売られすぎ70以上では買われすぎの水準。
+  #
+  #datas::  値の配列
+  #戻り値:: RSI値
+  def rsi( datas )
+    prev = nil
+    tmp = datas.inject( [0.0,0.0] ) {|r,i|
+      r[ i > prev ? 0 : 1 ] += (i - prev).abs if prev
+      prev = i
+      r
+    }
+    (tmp[0] + tmp[1] ) == 0 ? 0.0 : tmp[0] / (tmp[0] + tmp[1]) * 100
+  end
+
+  #===DMIを計算します。 
+  #  
+  # 高値更新  ...  前日高値より当日高値が高かった時その差
+  # 安値更新  ...  前日安値より当日安値が安かった時その差
+  # DM        ...  高値更新が安値更新より大きかった時高値更新の値。逆の場合は０
+  # DM        ...  安値更新が高値更新より大きかった時安値更新の値。逆の場合は０
+  # TR        ...  次の３つの中で一番大きいもの
+  #                  当日高値-当日安値
+  #                  当日高値-前日終値
+  #                  前日終値-当日安値
+  # AV(+DM)   ...  +DMのn日間移動平均値
+  # AV(-DM)   ...  -DMのn日間移動平均値
+  # AV(TR)    ...  TRのn日間移動平均値
+  # +DI       ...  AV(+DM)/AV(TR)
+  # -DI       ...  AV(-DM)/AV(TR)
+  # DX        ...  (+DIと-DIの差額) / (+DIと-DIの合計)
+  # ADX       ...  DXのn日平均値
+  #
+  #datas::  値の配列(4本値を指定すること!)
+  #戻り値:: {:pdi=pdi, :mdi=mdi, :dx=dx }
+  def dmi( datas )
+    prev = nil
+    tmp = datas.inject( [[],[],[]] ) {|r,i|
+      if prev
+        dm = _dmi( i, prev )
+        r[0] << dm[0] # TR
+        r[1] << dm[1] # +DM
+        r[2] << dm[2] # -DM
+      end
+      prev = i
+      r
+    }
+    atr = ma( tmp[0] )
+    pdi = ma( tmp[1] ) / atr * 100
+    mdi = ma( tmp[2] ) / atr * 100
+    dx  = ( pdi-mdi ).abs / ( pdi+mdi )  * 100
+    return {:pdi=>pdi, :mdi=>mdi, :dx=>dx }
+  end
+
+  #TR,+DM,-DMを計算します。
+  #戻り値:: [ tr, +DM, -DM ]
+  def _dmi( rate, rate_prev ) #:nodoc:
+    pdm = rate.max > rate_prev.max ? rate.max - rate_prev.max : 0
+    mdm = rate.min < rate_prev.min ? rate_prev.min - rate.min : 0
+
+    if ( pdm > mdm )
+      mdm = 0
+    elsif ( pdm < mdm )
+      pdm = 0
+    end
+
+    a = rate.max - rate.min
+    b = rate.max - rate_prev.end
+    c = rate_prev.end - rate.min
+    tr = [a,b,c].max
+
+    return [tr, pdm, mdm]
+  end
+
+  #===ROCを計算します。
+  #Rate of Change。変化率。正なら上げトレンド、負なら下げトレンド。
+  #
+  #datas::  値の配列
+  #戻り値:: 値
+  def roc( datas )
+    (datas.first - datas.last) / datas.last * 100
+  end
+end