Português PT
Ver no GitHub

Estratégia Simples iVIDyA

Visão geral

Esta estratégia é uma versão StockSharp de alto nível do especialista MetaTrader "iVIDyA Simple". Ele negocia um único símbolo rastreando uma Média Dinâmica de Índice Variável (VIDYA) que se adapta à dinâmica do mercado por meio do Chande Momentum Oscillator (CMO). Sempre que a vela finalizada mais recente cruza a linha VIDYA deslocada, a estratégia abre uma posição de mercado na direção do rompimento e, opcionalmente, anexa ordens protetoras de stop-loss e take-profit.

Lógica de negociação

  1. Os dados da vela são lidos no período configurado (CandleType).
  2. O CMO com período CmoPeriod está vinculado à série de velas. Seu valor absoluto dimensiona dinamicamente o fator de suavização do VIDYA. O fator base é igual a 2 / (EmaPeriod + 1) assim como a implementação original de MQL.
  3. Um valor VIDYA contínuo é mantido. Em cada vela finalizada, o algoritmo:
    • Seleciona o preço aplicado (AppliedPrice) da vela (fechamento, abertura, mediana, etc.).
    • Atualiza o VIDYA com o coeficiente de suavização adaptativo.
    • Armazena valores históricos para emular a opção MA shift de MetaTrader.
  4. A vela é comparada com o valor VIDYA deslocado (MaShift barras atrás):
    • Se a vela abrir abaixo de VIDYA e fechar acima dela, um sinal de compra será gerado.
    • Se a vela abrir acima de VIDYA e fechar abaixo dela, um sinal de venda será gerado.
  5. Antes de abrir uma nova posição, a estratégia nivela qualquer exposição oposta, negociando o volume total necessário para reverter.
  6. Após cada entrada, SetStopLoss e SetTakeProfit são chamados quando as respectivas distâncias são positivas.

Isso reflete o consultor especialista original, que acionou pedidos estritamente em novas barras, usou um VIDYA calculado a partir de períodos CMO e EMA e anexou paradas opcionais expressas em pontos.

Parâmetros

Nome Padrão Descrição
Volume 1 Volume base de negociação usado para pedidos. A exposição existente é compensada automaticamente ao inverter posições.
StopLossPoints 150 Distância de stop-loss em etapas de preço. Defina como 0 para desativar.
TakeProfitPoints 460 Distância de lucro em etapas de preço. Defina como 0 para desativar.
CmoPeriod 15 Comprimento do oscilador Chande Momentum que determina o peso adaptativo do VIDYA.
EmaPeriod 12 Comprimento EMA que define o coeficiente de suavização base na fórmula VIDYA.
MaShift 1 Número de velas concluídas usadas para deslocar a linha VIDYA para frente, correspondendo à entrada ma_shift do indicador MetaTrader.
AppliedPrice Close Fonte de preço passada para o cálculo VIDYA (Close, Open, High, Low, Median, Typical, Weighted).
CandleType TimeSpan.FromMinutes(5) Tipo de vela e prazo usado para todos os cálculos e sinais.

Notas adicionais

  • As ordens de proteção são gerenciadas por meio do API integrado de alto nível (SetStopLoss/SetTakeProfit), enquanto o código MQL original realizava verificações manuais em relação aos níveis de congelamento.
  • A estratégia assina apenas velas finalizadas, replicando a restrição de execução da "nova barra" de MetaTrader.
  • O histórico do VIDYA é cortado automaticamente para que o consumo de memória permaneça pequeno mesmo quando MaShift for grande.
  • Todos os comentários dentro do código são escritos em inglês para atender aos requisitos do projeto.
using System;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Simplified from "iVIDyA Simple" MetaTrader expert.
/// Computes a Variable Index Dynamic Average using CMO and EMA smoothing.
/// Trades when price crosses above/below the VIDYA line.
/// </summary>
public class IvidyaSimpleStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _cmoPeriod;
	private readonly StrategyParam<int> _emaPeriod;

	private ChandeMomentumOscillator _cmo;
	private decimal? _prevVidya;
	private decimal? _prevClose;

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public int CmoPeriod
	{
		get => _cmoPeriod.Value;
		set => _cmoPeriod.Value = value;
	}

	public int EmaPeriod
	{
		get => _emaPeriod.Value;
		set => _emaPeriod.Value = value;
	}

	public IvidyaSimpleStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(60).TimeFrame())
			.SetDisplay("Candle Type", "Primary candle series", "General");

		_cmoPeriod = Param(nameof(CmoPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("CMO Period", "Chande Momentum Oscillator length", "Indicator");

		_emaPeriod = Param(nameof(EmaPeriod), 30)
			.SetGreaterThanZero()
			.SetDisplay("EMA Period", "Base EMA length used by VIDYA", "Indicator");
	}

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

		_cmo = new ChandeMomentumOscillator { Length = CmoPeriod };
		_prevVidya = null;
		_prevClose = null;

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(_cmo, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);
		}
	}

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

		if (!_cmo.IsFormed)
			return;

		var close = candle.ClosePrice;

		// VIDYA = alpha * |CMO/100| * price + (1 - alpha * |CMO/100|) * prevVidya
		var alpha = 2m / (EmaPeriod + 1m);
		var momentumFactor = Math.Abs(cmoValue) / 100m;
		var sf = alpha * momentumFactor;

		var prevVidya = _prevVidya ?? close;
		var currentVidya = sf * close + (1m - sf) * prevVidya;

		if (_prevVidya is null || _prevClose is null)
		{
			_prevVidya = currentVidya;
			_prevClose = close;
			return;
		}

		// Price crosses above VIDYA -> buy
		var crossUp = _prevClose <= _prevVidya && close > currentVidya;
		// Price crosses below VIDYA -> sell
		var crossDown = _prevClose >= _prevVidya && close < currentVidya;
		var minDistance = close * 0.001m;

		var volume = Volume;
		if (volume <= 0)
			volume = 1;

		if (crossUp && Math.Abs(close - currentVidya) >= minDistance)
		{
			if (Position <= 0)
				BuyMarket(Position < 0 ? Math.Abs(Position) + volume : volume);
		}
		else if (crossDown && Math.Abs(close - currentVidya) >= minDistance)
		{
			if (Position >= 0)
				SellMarket(Position > 0 ? Math.Abs(Position) + volume : volume);
		}

		_prevVidya = currentVidya;
		_prevClose = close;
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		_cmo = null;
		_prevVidya = null;
		_prevClose = null;

		base.OnReseted();
	}
}