Deutsch DE
Auf GitHub ansehen

Vector-Strategie

Überblick

Die Vector-Strategie ist ein Multi-Währungs-Trendfolgesystem, das vom MetaTrader 5 "Vector"-Experten konvertiert wurde. Es handelt vier große Forex-Paare — EURUSD, GBPUSD, USDCHF und USDJPY — gleichzeitig. Die Strategie berechnet geglättete gleitende Durchschnitte auf dem Medianpreis jedes Paares und öffnet synchronisierte Positionen, wenn der kombinierte Trend in dieselbe Richtung weist. Ein dynamisches Pip-Ziel basierend auf der Vier-Stunden-Volatilität und Gewinn- und Verlust-Schwellenwerte auf Portfolioebene steuern die Ausstiege.

Kernideen

  • Geglättete gleitende Durchschnitte (SMMA) auf Medianpreisen verwenden, um die Richtung jedes Währungspaares zu messen.
  • Die schnellen und langsamen Durchschnitte aller Instrumente summieren, um eine gemeinsame bullische oder bearische Ausrichtung zu bestimmen.
  • Eine einzige Marktorder pro Paar eingeben, wenn die globale Ausrichtung und der lokale Schnell-/Langsam-Crossover übereinstimmen.
  • Positionen mit einem gleitenden Pip-Ziel verwalten, das aus dem durchschnittlichen Bereich von 50 abgeschlossenen 4-Stunden-Kerzen auf EURUSD abgeleitet wird.
  • Alle Trades gleichzeitig schließen, wenn der gleitende Gewinn oder Verlust den konfigurierten Prozentsatz des Startguthabens erreicht.

Parameter

Parameter Beschreibung
Fast MA Länge des geglätteten gleitenden Durchschnitts für den schnellen Trend jedes Paares.
Slow MA Länge des geglätteten gleitenden Durchschnitts für den langsamen Trend jedes Paares.
MA Shift Zusätzliche Anzahl abgeschlossener Kerzen, die benötigt werden, bevor Signale ausgewertet werden, entsprechend der Shift-Einstellung im ursprünglichen EA.
Equity Take Profit % Gleitender Gewinnprozentsatz, der das Schließen aller offenen Positionen auslöst.
Equity Stop Loss % Gleitender Verlustprozentsatz, der einen Notausstieg für alle Trades auslöst.
Signal Timeframe Kerzen-Zeitrahmen für die geglätteten gleitenden Durchschnitte (Standard 15 Minuten).
Range Timeframe Kerzen-Zeitrahmen für die Volatilitätsmittelung (Standard 4 Stunden).
Range Period Anzahl höherer Zeitrahmen-Kerzen für die Berechnung des durchschnittlichen Pip-Ziels.
EURUSD / GBPUSD / USDCHF / USDJPY Wertpapiere, die den einzelnen gehandelten Instrumenten entsprechen.

Alle Parameter unterstützen Optimierungsbereiche identisch zum ursprünglichen Expert Advisor, wo anwendbar.

Handelslogik

  1. Indikatoraktualisierung — Jede abgeschlossene Kerze auf einem Trading-Zeitrahmen aktualisiert die schnellen und langsamen geglätteten gleitenden Durchschnitte für das entsprechende Paar. Werte werden erst nach Abschluss des konfigurierten Aufwärmens (MA Shift) berücksichtigt.
  2. Bias-Berechnung — Die Strategie summiert die letzten schnellen Durchschnitte aller Paare und subtrahiert die Summe der langsamen Durchschnitte. Ein positives Ergebnis deutet auf bullischen Druck hin, ein negatives auf bearischen Druck.
  3. Einstiegsbedingungen — Wenn für ein Paar keine Position existiert, gibt die Strategie eine Kauforder ein, wenn die globale Ausrichtung bullisch ist und der schnelle Durchschnitt des Paares über dem langsamen liegt. In umgekehrtem Fall wird eine Verkaufsorder eröffnet.
  4. Pip-Ziel-Ausstieg — Das EURUSD-Vier-Stunden-Abonnement berechnet den durchschnittlichen Kerzenbereich über den konfigurierten Zeitraum. Das aktuelle Pip-Ziel ist das größere dieses Durchschnitts und 13 Pips. Longs schließen, sobald der Preis mindestens die Zielanzahl an Pips gewinnt, und Shorts schließen nach einer entsprechenden günstigen Bewegung.
  5. Kapitalschutz — Wenn der gleitende Gewinn den Take-Profit-Prozentsatz überschreitet oder der gleitende Verlust den Stop-Loss-Prozentsatz überschreitet, schließt die Strategie sofort alle verwalteten Positionen.

Verwendungshinweise

  • Fügen Sie die Strategie einem Portfolio hinzu, das Zugang zu allen vier Forex-Instrumenten bietet, und setzen Sie jeden Sicherheitsparameter explizit.
  • Der Standard-Signal-Zeitrahmen ist 15 Minuten; stellen Sie sicher, dass passende Kerzen für jedes Währungspaar verfügbar sind.
  • Pro Paar wird jederzeit nur eine offene Position gehalten. Der Volumenparameter der Basisstrategie wird für jeden Einstieg verwendet.
  • Da Ausstiege auf dem gleitenden G/V beruhen, ist die Strategie für den Dauerbetrieb und nicht nur für Kerzen-für-Kerzen-Backtesting gedacht.
  • Das dynamische Pip-Ziel verwendet die EURUSD-Volatilität entsprechend der ursprünglichen Implementierung. Passen Sie den Range-Zeitrahmen oder den Zeitraum an, wenn Sie das Ziel an eine andere Marktumgebung anpassen möchten.
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>
/// Trend strategy using smoothed moving averages. Simplified from multi-currency Vector.
/// </summary>
public class VectorStrategy : Strategy
{
	private readonly StrategyParam<int> _fastMaPeriod;
	private readonly StrategyParam<int> _slowMaPeriod;
	private readonly StrategyParam<int> _maShift;
	private readonly StrategyParam<decimal> _profitPercent;
	private readonly StrategyParam<decimal> _lossPercent;
	private readonly StrategyParam<DataType> _candleType;

	private SmoothedMovingAverage _fastMa;
	private SmoothedMovingAverage _slowMa;
	private decimal _entryPrice;
	private decimal _initialBalance;
	private int _processedBars;

	/// <summary>
	/// Fast smoothed moving average period.
	/// </summary>
	public int FastMaPeriod
	{
		get => _fastMaPeriod.Value;
		set => _fastMaPeriod.Value = value;
	}

	/// <summary>
	/// Slow smoothed moving average period.
	/// </summary>
	public int SlowMaPeriod
	{
		get => _slowMaPeriod.Value;
		set => _slowMaPeriod.Value = value;
	}

	/// <summary>
	/// Additional warm-up shift in bars.
	/// </summary>
	public int MaShift
	{
		get => _maShift.Value;
		set => _maShift.Value = value;
	}

	/// <summary>
	/// Floating profit target percent of balance.
	/// </summary>
	public decimal ProfitPercent
	{
		get => _profitPercent.Value;
		set => _profitPercent.Value = value;
	}

	/// <summary>
	/// Floating loss limit percent of balance.
	/// </summary>
	public decimal LossPercent
	{
		get => _lossPercent.Value;
		set => _lossPercent.Value = value;
	}

	/// <summary>
	/// Candle type for signals.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes strategy parameters.
	/// </summary>
	public VectorStrategy()
	{
		_fastMaPeriod = Param(nameof(FastMaPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("Fast MA", "Fast smoothed moving average period", "Indicators")
			.SetOptimize(3, 15, 1);

		_slowMaPeriod = Param(nameof(SlowMaPeriod), 7)
			.SetGreaterThanZero()
			.SetDisplay("Slow MA", "Slow smoothed moving average period", "Indicators")
			.SetOptimize(5, 25, 1);

		_maShift = Param(nameof(MaShift), 8)
			.SetNotNegative()
			.SetDisplay("MA Shift", "Additional warm-up bars before signals", "Indicators");

		_profitPercent = Param(nameof(ProfitPercent), 0.5m)
			.SetNotNegative()
			.SetDisplay("Equity TP %", "Close all when floating profit reaches this percent", "Risk");

		_lossPercent = Param(nameof(LossPercent), 30m)
			.SetNotNegative()
			.SetDisplay("Equity SL %", "Close all when floating loss reaches this percent", "Risk");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Signal Timeframe", "Timeframe for moving averages", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, CandleType);
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_fastMa = null;
		_slowMa = null;
		_entryPrice = 0m;
		_initialBalance = 0m;
		_processedBars = 0;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		_fastMa = new SmoothedMovingAverage { Length = FastMaPeriod };
		_slowMa = new SmoothedMovingAverage { Length = SlowMaPeriod };
		_initialBalance = Portfolio?.CurrentValue ?? 0m;

		SubscribeCandles(CandleType)
			.Bind(_fastMa, _slowMa, ProcessCandle)
			.Start();
	}

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

		_processedBars++;

		if (!IsFormed)
			return;

		if (_processedBars <= MaShift)
			return;

		// Check equity thresholds
		if (Position != 0 && _initialBalance > 0m)
		{
			var equity = Portfolio?.CurrentValue ?? 0m;
			var floating = equity - _initialBalance;
			var profitThreshold = _initialBalance * ProfitPercent / 100m;
			var lossThreshold = _initialBalance * LossPercent / 100m;

			if ((profitThreshold > 0m && floating >= profitThreshold) ||
				(lossThreshold > 0m && floating <= -lossThreshold))
			{
				if (Position > 0) SellMarket();
				else if (Position < 0) BuyMarket();
				_entryPrice = 0m;
				return;
			}
		}

		// Entry/exit logic
		if (fastValue > slowValue && Position <= 0)
		{
			if (Position < 0)
				BuyMarket();
			BuyMarket();
			_entryPrice = candle.ClosePrice;
		}
		else if (fastValue < slowValue && Position >= 0)
		{
			if (Position > 0)
				SellMarket();
			SellMarket();
			_entryPrice = candle.ClosePrice;
		}
	}
}