Estrategia de Mapa de Calor Stochastic
La estrategia Stochastic Heat Map promedia un conjunto de osciladores Stochastic con períodos crecientes. La lectura combinada se suaviza nuevamente para formar una línea rápida y una lenta. Las operaciones van largas cuando la línea rápida cruza por encima de la lenta y cortas en el cruce opuesto.
Detalles
- Criterios de entrada: cruce de línea rápida/lenta
- Largo/Corto: Ambos
- Criterios de salida: señal opuesta
- Stops: Ninguno
- Valores predeterminados:
CandleType= 15 minuteIncrement= 10SmoothFast= 2SmoothSlow= 21PlotNumber= 28
- Filtros:
- Categoría: Tendencia
- Dirección: Ambos
- Indicadores: Stochastic
- Stops: No
- Complejidad: Intermedio
- Marco temporal: Intradía
- Estacionalidad: No
- Redes neuronales: No
- Divergencia: No
- Nivel de riesgo: Medio
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>
/// Stochastic Heat Map strategy using EMA crossover.
/// </summary>
public class StochasticHeatMapStrategy : Strategy
{
private readonly StrategyParam<int> _slowLength;
private readonly StrategyParam<DataType> _candleType;
public int SlowLength { get => _slowLength.Value; set => _slowLength.Value = value; }
public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
public StochasticHeatMapStrategy()
{
_slowLength = Param(nameof(SlowLength), 40)
.SetGreaterThanZero()
.SetDisplay("Slow Length", "Slow EMA period", "General");
_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
.SetDisplay("Candle Type", "Candle type", "General");
}
public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
=> [(Security, CandleType)];
protected override void OnStarted2(DateTime time)
{
base.OnStarted2(time);
var fast = new ExponentialMovingAverage { Length = 14 };
var slow = new ExponentialMovingAverage { Length = SlowLength };
var prevF = 0m; var prevS = 0m; var init = false;
var lastSignal = DateTimeOffset.MinValue;
var cooldown = TimeSpan.FromMinutes(360);
var subscription = SubscribeCandles(CandleType);
subscription.Bind(fast, slow, (candle, f, s) =>
{
if (candle.State != CandleStates.Finished) return;
if (!fast.IsFormed || !slow.IsFormed) return;
if (!init) { prevF = f; prevS = s; init = true; return; }
if (candle.OpenTime - lastSignal >= cooldown)
{
if (prevF <= prevS && f > s && Position <= 0) { BuyMarket(); lastSignal = candle.OpenTime; }
else if (prevF >= prevS && f < s && Position >= 0) { SellMarket(); lastSignal = candle.OpenTime; }
}
prevF = f; prevS = s;
}).Start();
var area = CreateChartArea();
if (area != null) { DrawCandles(area, subscription); DrawIndicator(area, fast); DrawIndicator(area, slow); DrawOwnTrades(area); }
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import ExponentialMovingAverage
from StockSharp.Algo.Strategies import Strategy
class stochastic_heat_map_strategy(Strategy):
def __init__(self):
super(stochastic_heat_map_strategy, self).__init__()
self._slow_length = self.Param("SlowLength", 40) \
.SetGreaterThanZero() \
.SetDisplay("Slow Length", "Slow EMA period", "General")
self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5))) \
.SetDisplay("Candle Type", "Candle type", "General")
self._prev_f = 0.0
self._prev_s = 0.0
self._init = False
self._last_signal_ticks = 0
@property
def slow_length(self):
return self._slow_length.Value
@property
def candle_type(self):
return self._candle_type.Value
def OnReseted(self):
super(stochastic_heat_map_strategy, self).OnReseted()
self._prev_f = 0.0
self._prev_s = 0.0
self._init = False
self._last_signal_ticks = 0
def OnStarted2(self, time):
super(stochastic_heat_map_strategy, self).OnStarted2(time)
self._fast = ExponentialMovingAverage()
self._fast.Length = 14
self._slow = ExponentialMovingAverage()
self._slow.Length = self.slow_length
subscription = self.SubscribeCandles(self.candle_type)
subscription.Bind(self._fast, self._slow, self.on_candle).Start()
area = self.CreateChartArea()
if area is not None:
self.DrawCandles(area, subscription)
self.DrawIndicator(area, self._fast)
self.DrawIndicator(area, self._slow)
self.DrawOwnTrades(area)
def on_candle(self, candle, f, s):
if candle.State != CandleStates.Finished:
return
if not self._fast.IsFormed or not self._slow.IsFormed:
return
f = float(f)
s = float(s)
if not self._init:
self._prev_f = f
self._prev_s = s
self._init = True
return
cooldown_ticks = TimeSpan.FromMinutes(360).Ticks
current_ticks = candle.OpenTime.Ticks
if current_ticks - self._last_signal_ticks >= cooldown_ticks:
if self._prev_f <= self._prev_s and f > s and self.Position <= 0:
self.BuyMarket()
self._last_signal_ticks = current_ticks
elif self._prev_f >= self._prev_s and f < s and self.Position >= 0:
self.SellMarket()
self._last_signal_ticks = current_ticks
self._prev_f = f
self._prev_s = s
def CreateClone(self):
return stochastic_heat_map_strategy()