日本語 JA
GitHub で見る

ローソク足ヒゲ比率戦略

概要

ローソク足ヒゲ比率戦略は、MetaTraderエキスパートアドバイザーCandle shadow percentの直接移植版です。上ヒゲまたは下ヒゲがローソク足の実体の設定可能な割合に達するローソク足を探します。長い上ヒゲが現れると戦略はショートポジションを開き、深い下ヒゲが現れるとロングポジションを開きます。取引方向は元のアルゴリズムに合わせており、リスク管理ワークフローを intact に保ちます。

変換ノート

  • 元のエキスパートはカスタムインジケーターに依存していました。StockSharpバージョンでは、ヒゲと実体の比率は完成したローソク足から直接計算されるため、外部インジケーター依存性はありません。
  • Pip値はSecurity.PriceStepから導出されます。インストゥルメントのティックサイズに合わせてStopLossPips、TakeProfitPips、MinBodyPipsを調整してください。
  • リスクベースのポジションサイジングは、設定されたストップロス距離に対してポートフォリオの現在価値の一定割合をリスクにさらすことでMetaTraderのCMoneyFixedMarginロジックを再現します。

ローソク足の資格

ローソク足が取引の対象となるのは次の場合です：

  1. 絶対的な実体サイズが少なくともMinBodyPips * Security.PriceStepであること。
  2. 対応するヒゲが正であること。
  3. ヒゲ対実体比率が選択されたしきい値ロジックを満たすこと：
    • 上ヒゲ（売りセットアップ）：TopShadowIsMinimum = trueの場合(High − max(Open, Close)) / Body * 100がTopShadowPercent以上。そうでなければ以下でなければならない。
    • 下ヒゲ（買いセットアップ）：LowerShadowIsMinimum = trueの場合(min(Open, Close) − Low) / Body * 100がLowerShadowPercent以上。そうでなければ以下でなければならない。
  4. 同じローソク足で両方のヒゲがしきい値を満たす場合、戦略は二重シグナルを避けるために大きいヒゲ比率の側のみを保持します。

エントリールール

  • ショートエントリー – 戦略がフラットまたはロングのときに有効な上ヒゲシグナルで発動。戦略は必要に応じて既存のロングエクスポージャーを反転させ、保護注文を即座に設定します。
  • ロングエントリー – 戦略がフラットまたはショートのときに有効な下ヒゲシグナルで発動。既存のショートエクスポージャーは新しいロングポジションを確立する前に自動的に閉じられます。

終了ルール

  • ストップロス – エントリー価格からStopLossPips * Security.PriceStep離れた位置に配置。ロングポジションはエントリー − ストップ距離を使用；ショートポジションはエントリー + ストップ距離を使用。
  • テイクプロフィット – エントリーからTakeProfitPips * Security.PriceStepのオプションのターゲット。TakeProfitPips = 0の場合、ターゲットは無効化され、ポジションはストップロスまたは反対シグナルのみに依存して終了します。
  • 戦略は完成したローソク足を監視します。ローソク足の範囲がストップまたはターゲットに触れると、ポジションは次の処理サイクルで閉じられます。

ポジションサイジング

  • 取引ごとのリスクはPortfolio.CurrentValue * (RiskPercent / 100)として計算されます。ポートフォリオ価値が利用できない場合、戦略は設定された戦略ボリュームにフォールバックします。
  • 数量はリスク額をストップロス距離で割ったものと等しいです。反転時、アルゴリズムは完全な反転を確保するために現在のエクスポージャーの絶対サイズを加算し、元のMetaTraderエキスパートの動作に一致します。

パラメーター

パラメーター 説明
CandleType ローソク足購読に使用される時間軸またはデータタイプ。
StopLossPips インストゥルメントに対するpips/ticks単位のストップロス距離。ゼロより大きくなければならない。
TakeProfitPips pips/ticks単位のテイクプロフィット距離。ターゲットを無効にするにはゼロを使用。
RiskPercent 取引ごとにリスクにさらすポートフォリオ価値の割合。
MinBodyPips ヒゲ比率を評価する前に必要なローソク足の最小実体サイズ（pips/ticks）。
EnableTopShadow 上ヒゲの長さに基づいたショートシグナルを有効化。
TopShadowPercent 上ヒゲ対実体比率のしきい値パーセンテージ。
TopShadowIsMinimum trueの場合、比率はしきい値以上でなければならない；falseの場合、以下でなければならない。
EnableLowerShadow 下ヒゲの長さに基づいたロングシグナルを有効化。
LowerShadowPercent 下ヒゲ対実体比率のしきい値パーセンテージ。
LowerShadowIsMinimum 下ヒゲしきい値が最小条件として扱われるか最大条件として扱われるかを制御。

使用上のヒント

  • 元のEAに似た時間軸（例：5分足）から始め、インストゥルメントに合わせてpip距離を調整してください。
  • ノイズがシグナルを多く出しすぎる場合はMinBodyPipsを増やし、より小さなリバーサルを捉えるには減らしてください。
  • クラスを拡張することで追加のフィルター（トレンドインジケーターなど）と組み合わせることができます—追加のインジケーターのバインディングはOnStarted内に追加できます。
  • 本番環境に展開する前に、必ずデモポートフォリオでティックサイズの解釈を検証してください。
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Candle shadow percent strategy converted from MetaTrader.
/// Trades when a candle shows an extended wick compared to its body.
/// Position size is derived from risk percentage and stop distance.
/// </summary>
public class CandleShadowPercentStrategy : Strategy
{
	private readonly StrategyParam<int> _stopLossPips;
	private readonly StrategyParam<int> _takeProfitPips;
	private readonly StrategyParam<decimal> _riskPercent;
	private readonly StrategyParam<int> _minBodyPips;
	private readonly StrategyParam<bool> _enableTopShadow;
	private readonly StrategyParam<decimal> _topShadowPercent;
	private readonly StrategyParam<bool> _topShadowIsMinimum;
	private readonly StrategyParam<bool> _enableLowerShadow;
	private readonly StrategyParam<decimal> _lowerShadowPercent;
	private readonly StrategyParam<bool> _lowerShadowIsMinimum;
	private readonly StrategyParam<DataType> _candleType;
	
	private decimal? _longStop;
	private decimal? _longTake;
	private decimal? _shortStop;
	private decimal? _shortTake;
	private decimal? _entryPrice;
	
	/// <summary>
	/// Stop loss in pips.
	/// </summary>
	public int StopLossPips
	{
		get => _stopLossPips.Value;
		set => _stopLossPips.Value = value;
	}
	
	/// <summary>
	/// Take profit in pips.
	/// </summary>
	public int TakeProfitPips
	{
		get => _takeProfitPips.Value;
		set => _takeProfitPips.Value = value;
	}
	
	/// <summary>
	/// Risk percentage per trade.
	/// </summary>
	public decimal RiskPercent
	{
		get => _riskPercent.Value;
		set => _riskPercent.Value = value;
	}
	
	/// <summary>
	/// Minimum body size in pips to evaluate shadows.
	/// </summary>
	public int MinBodyPips
	{
		get => _minBodyPips.Value;
		set => _minBodyPips.Value = value;
	}
	
	/// <summary>
	/// Enables signals based on the top shadow.
	/// </summary>
	public bool EnableTopShadow
	{
		get => _enableTopShadow.Value;
		set => _enableTopShadow.Value = value;
	}
	
	/// <summary>
	/// Threshold for the top shadow as a percentage of the body.
	/// </summary>
	public decimal TopShadowPercent
	{
		get => _topShadowPercent.Value;
		set => _topShadowPercent.Value = value;
	}
	
	/// <summary>
	/// If true the top shadow percentage acts as a minimum threshold.
	/// </summary>
	public bool TopShadowIsMinimum
	{
		get => _topShadowIsMinimum.Value;
		set => _topShadowIsMinimum.Value = value;
	}
	
	/// <summary>
	/// Enables signals based on the lower shadow.
	/// </summary>
	public bool EnableLowerShadow
	{
		get => _enableLowerShadow.Value;
		set => _enableLowerShadow.Value = value;
	}
	
	/// <summary>
	/// Threshold for the lower shadow as a percentage of the body.
	/// </summary>
	public decimal LowerShadowPercent
	{
		get => _lowerShadowPercent.Value;
		set => _lowerShadowPercent.Value = value;
	}
	
	/// <summary>
	/// If true the lower shadow percentage acts as a minimum threshold.
	/// </summary>
	public bool LowerShadowIsMinimum
	{
		get => _lowerShadowIsMinimum.Value;
		set => _lowerShadowIsMinimum.Value = value;
	}
	
	/// <summary>
	/// Candle type used for calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}
	
	/// <summary>
	/// Initializes a new instance of the <see cref="CandleShadowPercentStrategy"/>.
	/// </summary>
	public CandleShadowPercentStrategy()
	{
		_stopLossPips = Param(nameof(StopLossPips), 50)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss", "Stop loss distance in pips", "Risk")
			;
		
		_takeProfitPips = Param(nameof(TakeProfitPips), 50)
			.SetNotNegative()
			.SetDisplay("Take Profit", "Take profit distance in pips", "Risk")
			;
		
		_riskPercent = Param(nameof(RiskPercent), 5m)
			.SetGreaterThanZero()
			.SetDisplay("Risk %", "Risk percentage per trade", "Risk")
			;
		
		_minBodyPips = Param(nameof(MinBodyPips), 300)
			.SetGreaterThanZero()
			.SetDisplay("Minimum Body", "Minimum candle body size in pips", "Pattern")
			;
		
		_enableTopShadow = Param(nameof(EnableTopShadow), true)
			.SetDisplay("Use Top Shadow", "Enable sell signals from upper wicks", "Pattern");
		
		_topShadowPercent = Param(nameof(TopShadowPercent), 30m)
			.SetNotNegative()
			.SetDisplay("Top Shadow %", "Upper wick percentage threshold", "Pattern")
			;
		
		_topShadowIsMinimum = Param(nameof(TopShadowIsMinimum), true)
			.SetDisplay("Top Shadow Uses Min", "If true the threshold is treated as a minimum", "Pattern");
		
		_enableLowerShadow = Param(nameof(EnableLowerShadow), true)
			.SetDisplay("Use Lower Shadow", "Enable buy signals from lower wicks", "Pattern");
		
		_lowerShadowPercent = Param(nameof(LowerShadowPercent), 80m)
			.SetNotNegative()
			.SetDisplay("Lower Shadow %", "Lower wick percentage threshold", "Pattern")
			;
		
		_lowerShadowIsMinimum = Param(nameof(LowerShadowIsMinimum), true)
			.SetDisplay("Lower Shadow Uses Min", "If true the threshold is treated as a minimum", "Pattern");
		
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe used for pattern detection", "Data");
	}
	
	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}
	
	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		
		_longStop = null;
		_longTake = null;
		_shortStop = null;
		_shortTake = null;
		_entryPrice = null;
	}
	
	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		
		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ProcessCandle)
			.Start();
		
		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}
	
	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;
		
		ManageOpenPosition(candle);
		
		var pipSize = GetPipSize();
		var minBody = MinBodyPips * pipSize;
		
		var body = Math.Abs(candle.ClosePrice - candle.OpenPrice);
		if (body < minBody || body <= 0m)
			return;
		
		var upperShadow = candle.HighPrice - Math.Max(candle.OpenPrice, candle.ClosePrice);
		var lowerShadow = Math.Min(candle.OpenPrice, candle.ClosePrice) - candle.LowPrice;
		
		var topRatio = body > 0m ? upperShadow / body * 100m : 0m;
		var lowerRatio = body > 0m ? lowerShadow / body * 100m : 0m;
		
		var topSignal = EnableTopShadow && upperShadow > 0m && CheckThreshold(topRatio, TopShadowPercent, TopShadowIsMinimum);
		var lowerSignal = EnableLowerShadow && lowerShadow > 0m && CheckThreshold(lowerRatio, LowerShadowPercent, LowerShadowIsMinimum);
		
		if (topSignal && lowerSignal)
		{
			if (topRatio > lowerRatio)
				lowerSignal = false;
			else
				topSignal = false;
		}
		
		if (topSignal && Position <= 0)
		{
			EnterShort(candle, pipSize);
		}
		else if (lowerSignal && Position >= 0)
		{
			EnterLong(candle, pipSize);
		}
	}
	
	private void ManageOpenPosition(ICandleMessage candle)
	{
		if (Position > 0)
		{
			var stopHit = _longStop.HasValue && candle.LowPrice <= _longStop.Value;
			var takeHit = _longTake.HasValue && candle.HighPrice >= _longTake.Value;
			
			if (stopHit || takeHit)
			{
				SellMarket();
				this.LogInfo($"Closing long at {candle.ClosePrice}. Stop hit: {stopHit}, Take hit: {takeHit}");
				_longStop = null;
				_longTake = null;
				_entryPrice = null;
			}
		}
		else if (Position < 0)
		{
			var stopHit = _shortStop.HasValue && candle.HighPrice >= _shortStop.Value;
			var takeHit = _shortTake.HasValue && candle.LowPrice <= _shortTake.Value;
			
			if (stopHit || takeHit)
			{
				BuyMarket();
				this.LogInfo($"Closing short at {candle.ClosePrice}. Stop hit: {stopHit}, Take hit: {takeHit}");
				_shortStop = null;
				_shortTake = null;
				_entryPrice = null;
			}
		}
	}
	
	private void EnterLong(ICandleMessage candle, decimal pipSize)
	{
		var stopDistance = StopLossPips * pipSize;
		if (stopDistance <= 0m)
			return;

		var takeDistance = TakeProfitPips * pipSize;

		var entryPrice = candle.ClosePrice;
		var stopPrice = entryPrice - stopDistance;
		var takePrice = takeDistance > 0m ? entryPrice + takeDistance : (decimal?)null;

		BuyMarket();

		_longStop = stopPrice;
		_longTake = takePrice;
		_shortStop = null;
		_shortTake = null;
		_entryPrice = entryPrice;

		this.LogInfo($"Entered long at {entryPrice}. Stop {stopPrice}, Take {(takePrice.HasValue ? takePrice.Value.ToString() : "n/a")}");
	}
	
	private void EnterShort(ICandleMessage candle, decimal pipSize)
	{
		var stopDistance = StopLossPips * pipSize;
		if (stopDistance <= 0m)
			return;

		var takeDistance = TakeProfitPips * pipSize;

		var entryPrice = candle.ClosePrice;
		var stopPrice = entryPrice + stopDistance;
		var takePrice = takeDistance > 0m ? entryPrice - takeDistance : (decimal?)null;

		SellMarket();

		_shortStop = stopPrice;
		_shortTake = takePrice;
		_longStop = null;
		_longTake = null;
		_entryPrice = entryPrice;

		this.LogInfo($"Entered short at {entryPrice}. Stop {stopPrice}, Take {(takePrice.HasValue ? takePrice.Value.ToString() : "n/a")}");
	}
	
	private decimal CalculatePositionSize(decimal stopDistance)
	{
		var defaultVolume = Volume > 0m ? Volume : 1m;
		
		var portfolioValue = Portfolio?.CurrentValue ?? Portfolio?.BeginValue ?? 0m;
		if (portfolioValue <= 0m)
			return defaultVolume;

		var riskAmount = portfolioValue * (RiskPercent / 100m);
		if (riskAmount <= 0m || stopDistance <= 0m)
			return defaultVolume;
		
		var size = riskAmount / stopDistance;
		return size > 0m ? size : defaultVolume;
	}
	
	private static bool CheckThreshold(decimal ratio, decimal threshold, bool isMinimum)
	{
		return isMinimum ? ratio >= threshold : ratio <= threshold;
	}
	
	private decimal GetPipSize()
	{
		return Security?.PriceStep ?? 1m;
	}
}