Deutsch DE
Auf GitHub ansehen

Binary Wave Strategie

Übersicht

Binary Wave kombiniert mehrere klassische technische Indikatoren zu einer einzigen „binären" Welle. Jeder Indikator trägt je nach bullischem oder bärischem Zustand entweder +1 oder -1 bei. Die gewichtete Summe aller Signale bildet die endgültige Welle, die für Handelsentscheidungen verwendet wird.

Parameter

  • Mode – Einstiegsalgorithmus: Breakdown reagiert auf Null-Kreuzungen; Twist reagiert auf Richtungsänderungen der Welle.
  • Candle Type – Zeitrahmen der Kerzen für alle Berechnungen.
  • Indicator Periods – Längen für MA, MACD (schnell, langsam, Signal), CCI, Momentum, RSI und ADX.
  • Weights – Beitrag jedes Indikators zur Welle. Ein Gewicht von 0 deaktiviert den Indikator.
  • Trading Permissions – Long/Short-Einstiege und -Ausstiege separat aktivieren oder deaktivieren.
  • Risk – Stop-Loss und Take-Profit in Prozent des Einstiegspreises.

Funktionsweise

  1. Die angegebene Kerzenserie abonnieren und alle Indikatoren berechnen.
  2. Für jede abgeschlossene Kerze den Zustand jedes Indikators bewerten und in einen Binärwert (+1 / -1) umwandeln.
  3. Gewichtete Werte summieren, um die aktuelle Welle zu erhalten.
  4. Handelssignale generieren:
    • Breakdown: Long einsteigen, wenn die Welle über null kreuzt; Short einsteigen, wenn sie unter null kreuzt.
    • Twist: Long einsteigen, wenn die Welle die Richtung nach oben ändert; Short einsteigen, wenn sie nach unten dreht.
  5. Optionaler Schutz-Stop-Loss und Take-Profit werden durch den integrierten Positionsschutz verwaltet.

Dieser Ansatz ermöglicht die flexible Kombination mehrerer Indikatoren bei gleichzeitig einfacher Handelslogik.

using System;
using System.Collections.Generic;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Binary Wave strategy using EMA crossover.
/// </summary>
public class BinaryWaveStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;

	private decimal _prevFast;
	private decimal _prevSlow;
	private bool _hasPrev;

	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }

	public BinaryWaveStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe", "General");

		_fastPeriod = Param(nameof(FastPeriod), 12)
			.SetGreaterThanZero()
			.SetDisplay("Fast Period", "Fast EMA period", "Indicators");

		_slowPeriod = Param(nameof(SlowPeriod), 26)
			.SetGreaterThanZero()
			.SetDisplay("Slow Period", "Slow EMA period", "Indicators");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	protected override void OnReseted()
	{
		base.OnReseted();
		_prevFast = 0;
		_prevSlow = 0;
		_hasPrev = false;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		var fast = new ExponentialMovingAverage { Length = FastPeriod };
		var slow = new ExponentialMovingAverage { Length = SlowPeriod };

		SubscribeCandles(CandleType)
			.Bind(fast, slow, ProcessCandle)
			.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastVal, decimal slowVal)
	{
		if (candle.State != CandleStates.Finished) return;

		if (!_hasPrev)
		{
			_prevFast = fastVal;
			_prevSlow = slowVal;
			_hasPrev = true;
			return;
		}

		var crossUp = _prevFast <= _prevSlow && fastVal > slowVal;
		var crossDown = _prevFast >= _prevSlow && fastVal < slowVal;

		if (crossUp && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
		}
		else if (crossDown && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
		}

		_prevFast = fastVal;
		_prevSlow = slowVal;
	}
}