
La stratégie d’une plage de pierre est une stratégie de trading quantitative qui suit la loi de Brady. Elle utilise une entrée de rupture de prix, une sortie de rupture de suivi, une taille de position calculée en fonction de l’amplitude réelle de la vague et un contrôle strict des pertes individuelles.
La stratégie de la pirate solide comme le roc consiste à faire une entrée de rupture. Plus précisément, elle calcule le prix le plus élevé et le prix le plus bas d’un certain cycle en fonction des paramètres de la période de rupture entrée.
Par exemple, si le paramètre de cycle d’entrée est de 20 lignes K, la stratégie extrait le prix le plus élevé et le prix le plus bas des 20 dernières lignes K. Si le prix de clôture de la ligne K actuelle est supérieur au prix le plus élevé des 20 dernières lignes K, la stratégie émet plusieurs ordres d’arrêt à cette position de prix de clôture, en attendant le prix d’entrée le plus élevé.
La stratégie de pirate solide comme le roc suit les sorties de stop loss. Elle calcule dynamiquement les prix les plus élevés et les plus bas d’un certain cycle en fonction des paramètres de cycle de sortie des entrées. Cela devient le canal de sortie de la stratégie.
Lorsqu’une position est détenue en plusieurs fois, la position est arrêtée si le prix est inférieur au prix le plus bas de la sortie du canal. Inversement, lorsqu’une position est détenue en position vide, la position est arrêtée si le prix est supérieur au prix le plus élevé de la sortie du canal.
En outre, la stratégie calcule le stop loss en fonction de l’amplitude réelle de la vague, comme dernière ligne de stop loss. Tant que le prix ne franchit pas la sortie du canal, le stop loss suit la correction en veillant à ce que la distance de stop loss soit juste, ni trop radicale pour entraîner des pertes inutiles, ni trop éloignée pour contrôler efficacement les pertes.
Une stratégie de pirate solide comme le roc calcule la taille d’une seule position en fonction de l’amplitude réelle. Plus précisément, elle calcule d’abord le pourcentage de perte potentielle près du prix d’entrée, puis renvoie la taille de la position en fonction des paramètres de risque attendus.
Les stratégies de piratage dur comme pierre suivent les règles de Brady piratage, en appliquant strictement les règles d’entrée et de sortie, et ne changent pas au hasard. Cela permet aux stratégies de fonctionner de manière stable à long terme, sans que le système ne tombe en panne à cause d’erreurs de jugement temporaires.
La stratégie consiste à adopter une méthode d’entrée de rupture de prix, ce qui permet d’éviter efficacement le risque d’entrée de faille à des niveaux élevés, réduisant ainsi le risque de pertes systémiques. En même temps, l’utilisation d’une méthode d’arrêt de suivi des pertes assure le contrôle des pertes individuelles et limite au maximum les retombées causées par des pertes continues.
La stratégie consiste à calculer les positions en utilisant une amplitude d’onde réelle, à contrôler strictement la perte maximale de chaque transaction dans les limites autorisées, à éviter les risques de débordement causés par des pertes massives. En même temps, l’utilisation d’un suivi des pertes pour s’assurer que les pertes sont suffisamment éloignées, peut arrêter les pertes à temps et contrôler efficacement les risques.
Si la perturbation de la rupture n’est pas accompagnée d’une perturbation, il est facile de former de faux signaux entraînant des pertes d’entrée de jeu erronées du système. Il est alors nécessaire d’ajuster les paramètres, d’augmenter les conditions de confirmation d’entrée et d’éviter les interférences sonores d’une rupture invalide.
Les paramètres de la stratégie, tels que le cycle d’entrée, le cycle de sortie, etc., sont statiques. Si l’environnement du marché change considérablement, ces paramètres peuvent être invalidés. Il est alors nécessaire de réévaluer les paramètres définis et d’optimiser les paramètres pour s’adapter aux nouvelles conditions du marché.
La stratégie utilise des indicateurs techniques tels que les flags de rupture de prix. Ces indicateurs techniques peuvent être invalidés lorsque les tendances du marché et les modèles de volatilité changent de manière significative. Il est alors nécessaire d’introduire davantage de jugements sur les indicateurs techniques pour optimiser la fiabilité de la stratégie globale.
Il est possible d’ajouter à la stratégie des indicateurs de jugement de tendance couramment utilisés, tels que MA, MACD, etc. Le fait de juger de la tendance haussière en faisant plus et de juger de la tendance baissière en faisant moins peut réduire les pertes de l’opération inverse.
Des indicateurs techniques de cadres horaires de niveau supérieur peuvent être introduits pour un jugement global. Par exemple, la position de la ligne MA au niveau 86400 peut déterminer la direction générale du mouvement et confirmer davantage les signaux d’opération sur le graphique temporel.
Il est possible d’optimiser automatiquement les paramètres en fonction des données historiques et d’ajuster les paramètres en temps réel pour s’adapter à l’évolution de l’environnement du marché, par des moyens tels que l’apprentissage automatique. Cela peut rendre la stratégie plus adaptable et stable.
Les stratégies de piratage robustes comme le roc suivent les règles classiques de la piratage, avec des entrées et des sorties de perte de suivi de perte de suivi de perte, un contrôle strict des risques, un fonctionnement stable à long terme et une excellente capacité d’anti-baisse. Bien que certains risques, tels que l’échec de la rupture et l’échec des paramètres, doivent encore être prévenus, ces risques peuvent être efficacement réduits en introduisant des moyens tels que le jugement de tendance, le jugement du cadre temporel et l’optimisation des paramètres dynamiques.
/*backtest
start: 2024-01-18 00:00:00
end: 2024-02-17 00:00:00
period: 2h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("Real Turtle", shorttitle = "Real Turtle", overlay=true, pyramiding=1, default_qty_type= strategy.percent_of_equity,calc_on_order_fills=false, slippage=25,commission_type=strategy.commission.percent,commission_value=0.075)
//////////////////////////////////////////////////////////////////////
// Testing Start dates
testStartYear = input(2016, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
//Stop date if you want to use a specific range of dates
testStopYear = input(2030, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(30, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
// A switch to control background coloring of the test period
// Use if using a specific date range
testPeriodBackground = input(title="Color Background?", type=bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and (time >= testPeriodStart) and (time <= testPeriodStop) ? #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)
testPeriod() => true
// Component Code Stop
//////////////////////////////////////////////////////////////////////
//How many candles we want to determine our position entry
enterTrade = input(20, minval=1, title="Entry Channel Length")
//How many candles we want ot determine our position exit
exitTrade = input(10, minval=1, title="Exit Channel Length")
//True Range EMA Length
trLength = input(13, minval=1, title="True Range Length")
//Go all in on every trade
allIn = input(false, title="Use whole position on every trade")
dRisk = input(2, "Use Desired Risk %")
//How much of emaTR to use for TS offset
multiEmaTR = input(2, "Desired multiple of ema Tr (N)")
//absolute value (highest high of of this many candles - lowest high of this many candles) . This is used if we want to change our timeframe to a higher timeframe otherwise just works like grabbing high o r low of a candle
//True range is calculated as just high - low. Technically this should be a little more complicated but with 24/7 nature of crypto markets high-low is fine.
trueRange = max(high - low, max(high - close[1], close[1] - low))
//Creates an EMA of the true range by our custom length
emaTR = ema(trueRange, trLength)
//Highest high of how many candles back we want to look as specified in entry channel for long
longEntry = highest(enterTrade)
//loweest low of how many candles back we want to look as specified in exit channel for long
exitLong = lowest(exitTrade)
//lowest low of how many candles back want to look as specified in entry channel for short
shortEntry = lowest(enterTrade)
//lowest low of how many candles back want to look as specified in exit channel for short
exitShort = highest(exitTrade)
//plots the longEntry as a green line
plot(longEntry[1], title="Long Entry",color=green)
//plots the short entry as a purple line
plot(shortEntry[1], title="Short Entry",color=purple)
howFar = barssince(strategy.position_size == 0)
actualLExit = strategy.position_size > 0 ? strategy.position_avg_price - (emaTR[howFar] * multiEmaTR) : longEntry - (emaTR * multiEmaTR)
actualLExit2 = actualLExit > exitLong ? actualLExit : exitLong
actualSExit = strategy.position_size < 0 ? strategy.position_avg_price + (emaTR[howFar] * multiEmaTR) : shortEntry + (emaTR * multiEmaTR)
actualSExit2 = actualSExit < exitShort ? actualSExit : exitShort
//plots the long exit as a red line
plot(actualLExit2[1], title="Long Exit",color=red)
//plots the short exit as a blue line
plot(actualSExit2[1], title="Short Exit",color=yellow)
//Stop loss in ticks
SLLong =(emaTR * multiEmaTR)/ syminfo.mintick
SLShort = (emaTR * multiEmaTR)/ syminfo.mintick
//Calculate our potential loss as a whole percentage number. Example 1 instead of 0.01 for 1% loss. We have to convert back from ticks to whole value, then divided by close
PLLong = ((SLLong * syminfo.mintick) * 100) / longEntry
PLShort = ((SLShort * syminfo.mintick) * 100) / shortEntry
//Calculate our risk by taking our desired risk / potential loss. Then multiple by our equity to get position size. we divide by close because we are using percentage size of equity for quantity in this script as not actual size.
//we then floor the value. which is just to say we round down so instead of say 201.54 we would just input 201 as TV only supports whole integers for quantity.
qtyLong = floor(((dRisk / PLLong) * strategy.equity) /longEntry )
qtyShort = floor(((dRisk / PLShort) * strategy.equity) /shortEntry )
qtyLong2 = allIn ? 100 : qtyLong
qtyShort2 = allIn ? 100 : qtyShort
//Only open long or short positions if we are inside the test period specified earlier
if testPeriod()
//Open a stop market order at our long entry price and keep it there at the quantity specified. This order is updated/changed on each new candlestick until a position is opened
strategy.entry("long", strategy.long, stop = longEntry, qty = qtyLong2)
//sets up or stop loss order by price specified in our actualLExit2 variable
strategy.exit("Stoploss-Long", "long", stop=actualLExit2)
//Open a stop market order at our short entry price and keep it there at the quantity specified. This order is updated/changed on each new candlestick until a position is opened
strategy.entry("short", strategy.short, stop = shortEntry, qty = qtyShort2)
//sets up or stop loss order by price specified in our actualLExit2 variable
strategy.exit("Stoploss-Short", "short", stop=actualSExit2)