Stochastic Heat Map-Strategie
Die Stochastic Heat Map-Strategie mittelt eine Reihe von Stochastic-Oszillatoren mit steigenden Perioden. Der kombinierte Wert wird erneut geglättet, um eine schnelle und eine langsame Linie zu bilden. Trades gehen long, wenn die schnelle Linie die langsame nach oben kreuzt, und short beim umgekehrten Kreuzungspunkt.
Details
- Einstiegskriterien: schnell/langsam-Kreuzung
- Long/Short: Beide
- Ausstiegskriterien: entgegengesetztes Signal
- Stops: Keine
- Standardwerte:
CandleType= 15 minuteIncrement= 10SmoothFast= 2SmoothSlow= 21PlotNumber= 28
- Filter:
- Kategorie: Trend
- Richtung: Beide
- Indikatoren: Stochastic
- Stops: Nein
- Komplexität: Mittel
- Zeitrahmen: Intraday
- Saisonalität: Nein
- Neuronale Netze: Nein
- Divergenz: Nein
- Risikolevel: Mittel
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()