L'idée principale de cette stratégie est de simuler les transactions en temps réel, de collecter des données de transactions hebdomadaires et de présenter les résultats statistiques sous forme de tableaux afin d'avoir une vue plus intuitive de la performance de la stratégie. Cela nous aide à évaluer rapidement les gains et les pertes de la stratégie, à identifier les périodes où la stratégie ne fonctionne pas bien et à adapter et optimiser la stratégie en conséquence.
Définir les heures de début et de fin du cycle de calcul.
La précision des résultats statistiques et le nombre de semaines contenues dans chaque groupe sont définis.
Il y a aussi une stratégie d'achat et de vente simulant le RSI.
Définition des variables dans la table des statistiques.
Calculer le résultat du cycle en cours.
Si le cycle change et autorise la transaction, il faut enregistrer le temps et le résultat de ce cycle.
Si c'est la dernière ligne K et que la transaction est autorisée, l'heure et le résultat du cycle en cours sont enregistrés.
Si le cycle change et n'autorise pas les transactions, les dates et les résultats du cycle précédent sont enregistrés.
Trouver les résultats cycliques les plus élevés et les plus bas.
Les statistiques de rendu.
Comptez d'abord le nombre total de cycles.
Parcourez chaque cycle, rendant les titres, les temps et les résultats
Accumuler les résultats de chaque groupe de cycles
Les résultats positifs et négatifs sont marqués en couleur.
Vous pouvez voir les résultats des transactions hebdomadaires en temps réel et évaluer rapidement les performances de votre stratégie.
La présentation intuitive des résultats, au premier coup d'œil, permet d'identifier les cycles de mauvaise performance des stratégies.
Les paramètres stratégiques peuvent être ajustés et optimisés en fonction des pertes et gains de la période.
Vous pouvez facilement suivre les gains cumulés sur plusieurs semaines de votre stratégie de détention à long terme.
Une analyse comparative des styles de négociation à différentes périodes
Personnaliser la précision statistique et le nombre de semaines de segmentation pour répondre à des besoins différents
Le code est simple, clair, facile à comprendre et à développer
Cette stratégie est basée sur le RSI pour effectuer des transactions simulées. La stratégie RSI présente elle-même des inconvénients en ce qu'elle ne suit pas suffisamment la tendance.
Dans le cas réel, les frais de transaction ont un impact plus important sur les résultats.
Les données historiques utilisées pour les retrospectives ne reflètent pas nécessairement l'environnement des transactions réelles.
Les résultats statistiques sont basés sur le montant réel des fonds du compte, et le montant par défaut de la réévaluation n'est pas toujours exact.
Veillez à éviter les surajustements et modifiez aveuglément les paramètres stratégiques en fonction des résultats des retests.
La stratégie RSI peut être renforcée en combinant plus d'indicateurs pour déterminer les tendances, optimiser les points d'entrée et de sortie.
Vous pouvez envisager d'intégrer une logique de stop-loss pour contrôler vos pertes.
Des paramètres stratégiques peuvent être optimisés, tels que l'ajustement des seuils haussifs et bassifs du RSI.
Vous pouvez essayer différentes fréquences de négociation, par exemple des transactions en une journée ou des positions mensuelles.
Plus d'indicateurs peuvent être ajoutés pour déterminer les tendances du marché et le moment d'entrée
Il est possible d'envisager une logique de blocage.
Les paramètres statistiques peuvent être optimisés
Des statistiques sur les différents actifs peuvent être envisagées.
L'ajout d'un stop-loss peut améliorer le contrôle des risques et des gains. Optimiser les paramètres RSI peut améliorer les taux de réussite. Adopter plus d'indicateurs et une fréquence de trading différente peut rendre la stratégie plus stable. Modifier les paramètres statistiques peut rendre les résultats plus importants.
Le but de cette stratégie est de collecter les résultats des transactions cycliques et de les présenter de manière intuitive sous la forme de tableaux statistiques, ce qui permet de déterminer rapidement les pertes et les gains de la stratégie à différentes périodes de temps. Cela fournit un support de données pour l'optimisation de la stratégie. L'avantage est que les résultats hebdomadaires peuvent être vus en temps réel, sont intuitifs et faciles à développer. Il convient de noter que les résultats statistiques peuvent entraîner une dépendance excessive et une adaptation des données de réponse.
/*backtest
start: 2023-09-12 00:00:00
end: 2023-10-12 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
// strategy('Strategy weekly results as numbers v1', overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=25, commission_type=strategy.commission.percent, commission_value=0.04)
after = input(title='Trade after', defval=timestamp('01 Jan 2019 00:00 UTC'), tooltip="Strategy will be executed after this timestamp. The statistic table will include only periods after this date.")
before = input(title='Trade before', defval=timestamp('31 Dec 2024 23:59 UTC'), tooltip="Strategy will be executes before this timestamp. The statistic table will include only periods before this date.")
statisticPrecision = input.int(title='Statistic precision', group='Statistic visualisation', defval=1, tooltip="Defines how many digits should be rendered in every statistic cell.")
statisticGroupSize = input.int(title='Statistic group size', group='Statistic visualisation', defval=12, tooltip="Defines how many cells should be in one group inside the statistic table.")
// determinet whether the starategy should be traded between the period
isTradeEnabled = true
// *******************************************************************************************
// Core strategy simulation logic
// *******************************************************************************************
// calculate rsi strategy emulation data
rsiEmulationData = ta.rsi(close, 7)
rsiEmulationCrossover = ta.crossover(rsiEmulationData, 70)
rsiEmulationCrossunder = ta.crossunder(rsiEmulationData, 30)
// entry loogic based on the rsi calculations
if (isTradeEnabled and rsiEmulationCrossover)
strategy.entry('Long', strategy.long)
if (isTradeEnabled and rsiEmulationCrossunder)
strategy.entry('Short', strategy.short)
// *******************************************************************************************
// Weekly statistics table
// *******************************************************************************************
// define statistic variables
var statisticTable = table(na)
var statisticPeriodTime = array.new_int(0)
var statisticPeriodResult = array.new_float(0)
var statisticIsLatestCalculated = bool(na)
var statisticResultHighest = float(na)
var statisticResultLowest = float(na)
var statisticColorGray = color.new(color.gray, transp = 60)
var statisticColorGreen = color.new(color.green, transp = 60)
var statisticColorRed = color.new(color.red, transp = 60)
// claculate current period result
barResult = not na(strategy.equity[1])
? (strategy.equity / strategy.equity[1] - 1) : 0
isPeriodChanged = not na(time[1]) and weekofyear(time) != weekofyear(time[1])
currentPeriodResult = 0.0
currentPeriodResult := not na(currentPeriodResult[1]) and not isPeriodChanged
? ((1 + currentPeriodResult[1]) * (1 + barResult) - 1) : 0.0
// initialise highest and lowest results variables
statisticResultHighest := na(statisticResultHighest) ? currentPeriodResult : statisticResultHighest
statisticResultLowest := na(statisticResultLowest) ? currentPeriodResult : statisticResultLowest
// search for highest and lowest results
statisticResultHighest := currentPeriodResult > statisticResultHighest ? currentPeriodResult : statisticResultHighest
statisticResultLowest := currentPeriodResult < statisticResultLowest ? currentPeriodResult : statisticResultLowest
// new week while trade is active
if isPeriodChanged and isTradeEnabled
timeCalculated = time - 1000 * 60 * 60 * 24 * 7
resultCalculated = currentPeriodResult[1]
statisticIsLatestCalculated := false
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// latest bar while trade is active
if barstate.islast and isTradeEnabled
timeCalculated = time - 1000 * 60 * 60 * 24 * (dayofweek(time) - 2)
resultCalculated = currentPeriodResult
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// new week after trade disabled
if isPeriodChanged and not isTradeEnabled and not na(statisticIsLatestCalculated) and not statisticIsLatestCalculated
timeCalculated = time - 1000 * 60 * 60 * 24 * (dayofweek(time) + 5)
resultCalculated = currentPeriodResult[1]
statisticIsLatestCalculated := true
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// render statistics table
if barstate.islast
statisticLength = array.size(statisticPeriodResult)
statisticTableSteps = math.floor(statisticLength / statisticGroupSize) + (statisticLength % statisticGroupSize != 0 ? 1 : 0)
statisticTable := table.new(position.bottom_right, columns = statisticGroupSize + 2, rows = statisticTableSteps + 1, border_width = 1)
// render headers
for i = 0 to (statisticGroupSize - 1)
statisticHeaderContent = str.tostring(i + 1)
table.cell(statisticTable, 1 + i, 0, statisticHeaderContent, bgcolor = statisticColorGray)
// render time points
for i = 0 to (statisticTableSteps - 1)
statisticPointContent = str.format("{0,date,medium}", array.get(statisticPeriodTime, i * statisticGroupSize))
table.cell(statisticTable, 0, 1 + i, statisticPointContent, bgcolor = statisticColorGray)
// render the result
statisticResultCummulative = 0.0
for i = 0 to (array.size(statisticPeriodTime) - 1)
statisticColumn = 1 + i % statisticGroupSize
statisticRow = 1 + math.floor(i / statisticGroupSize)
statisticResult = array.get(statisticPeriodResult, i)
statisticResultCummulative := (i % statisticGroupSize == 0) ? 0.0 : statisticResultCummulative
statisticResultCummulative := (1 + statisticResultCummulative) * (1 + statisticResult) - 1
statisticResultColor = statisticResult > 0 ? statisticColorGreen : statisticColorRed
table.cell(statisticTable, statisticColumn, statisticRow, str.tostring(math.round(statisticResult * 100, statisticPrecision)), bgcolor = statisticResultColor)
// if it is the last item of the row or data array
isStatisticLastOfTheRow = ((i + 1) % statisticGroupSize) == 0
isStatisticLastOfTheData = i == (statisticLength - 1)
if (isStatisticLastOfTheRow or isStatisticLastOfTheData)
resultsTableCummulativeCellColor = statisticResultCummulative > 0 ? statisticColorGreen : statisticColorRed
resultsTableCummulativeCellContent = str.tostring(math.round(statisticResultCummulative * 100, statisticPrecision))
table.cell(statisticTable, 1 + statisticGroupSize, statisticRow, resultsTableCummulativeCellContent, bgcolor = resultsTableCummulativeCellColor)