Momentum-Brick-Strategie

Schriftsteller:ChaoZhang, Datum: 2024-02-19 15:32:17
Tags:

Die Strategie beurteilt die Veränderung der Marktdynamik anhand der Bildung simulierter Bausteine und der Richtung der Bausteine.

Strategie Logik

Die Kernlogik besteht darin, die Ziegelbildung zu simulieren, indem die ATR- und Schlusskursbeziehung berechnet wird.

Brick1 wird berechnet, indem: wenn der Schlusskurs den vorherigen Wert von Brick1 + ATR übersteigt, Brick1 = Brick1 vorheriger Wert + ATR; wenn der Schlusskurs unter Brick1 vorheriger - ATR liegt, ist Brick1 Brick1 vorheriger - ATR Wert; andernfalls erbt Brick1 den vorherigen Wert von Brick1.

Brick2 wird so berechnet: Wenn Brick1 nicht dem vorherigen Wert von Brick1 entspricht, dann ist Brick2 = Brick1 vorheriger Wert; andernfalls erben Sie den vorherigen Wert von Brick2.

Dies simuliert die Ziegelbildung. Wenn Ziegel 1 mehr als eine ATR ansteigt, bildet sich ein aufwärts gerichteter Ziegel; wenn Ziegel 1 mehr als eine ATR fällt, bildet sich ein abwärts gerichteter Ziegel. Ziegel 2 zeichnet nur die Position des vorherigen Ziegels auf.

Wenn Brick1 und Brick2 sich überschneiden, bedeutet das, dass der Ziegel nach oben expandiert, als lang beurteilt. Wenn Brick1 und Brick2 sich überschneiden, bedeutet das, dass der Ziegel nach unten schrumpft, als kurz beurteilt.

Vorteil

Verwenden Sie ATR zur Bestimmung der Ziegelbildung, vermeiden Sie feste Ziegelgröße, können sich dynamisch an die Marktschwankungen anpassen
Identifizieren von Impulsveränderungen durch Kreuzung von Steinen
Die Empfindlichkeit für die Beurteilung der Marktdynamik kann durch verschiedene ATR-Zyklen angepasst werden.
Visualisieren Sie die Bildung und Kreuzung von Ziegeln, um Markttrends intuitiv zu bestimmen

Risiken

Die Auswahl der ATR-Größe beeinflusst die Strategierenditen. Zu geringe ATR führt zu zu vielen ungültigen Signalen. Zu große ATR führt zu zu wenigen Ziegeln und möglichem Verlust von Gelegenheiten.
Der tatsächliche Trend kann nicht dem Ziegelmuster folgen.
Die Kommission hat in diesem Zusammenhang eine Reihe von Maßnahmen ergriffen, um die Verringerung der Kosten für die Transaktion zu gewährleisten.

Die Lösungen umfassen die Optimierung von Parametern, um einen optimalen ATR-Zyklus zu finden, die Stop-Profit-Loss-Strategie anzupassen, um Verluste durch ungültige Signale zu reduzieren, die Transaktionsvarianten angemessen zu erhöhen, um die Kostenwirkung auf die Rendite zu reduzieren.

Optimierung

Kombination mit anderen Signalfiltern, um ungültige Signale zu vermeiden, z. B. Volumen- und Volatilitätsindikatoren
Hinzufügen von Trendfiltern, Ausgabe von Signalen nur in Trendrichtung, um Umkehrverluste zu vermeiden
Übernahme der vollständigen Probenparameteroptimierung während der Testphase, um automatisch optimale Parameter zu finden

Zusammenfassung

Die Strategie beurteilt kurzfristige Trends und Dynamik in den Märkten durch dynamische Simulation von Blockcrossover mit intuitiver Visualisierung.

/*backtest
start: 2023-02-12 00:00:00
end: 2024-02-18 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4


///Component Code Start
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(01, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear, testStartMonth, testStartDay, 0, 0)

testStopYear = input(2025, "Backtest Stop Year")
testStopMonth = input(1, "Backtest Stop Month")
testStopDay = input(1, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear, testStopMonth, testStopDay, 0, 0)



/// A switch to control background coloring of the test period
testPeriodBackground = input(title="Color Background?", type=input.bool, defval=false)
testPeriodBackgroundColor = testPeriodBackground and time >= testPeriodStart and time <= testPeriodStop ? 
   #00FF00 : na
bgcolor(testPeriodBackgroundColor, transp=97)

testPeriod() => true
/// Component Code Stop


//Zack_the_Lego (original AUTHOR) made into strategy by mkonsap
strategy("Flex Renko Emulator", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
margin = input(true, title="Margin?")
Margin = margin ? margin : false
res = input(type=input.resolution, defval="D", title="Resolution of ATR")
xATR = atr(14)
//TF = x78tf ? "78" : "39"
BrickSize = security(syminfo.tickerid, res, xATR)

//Brick1 =  close >  nz(Brick1[1]) + BrickSize ? nz(Brick1[1]) + BrickSize : close <
                    //nz(Brick1[1]) - BrickSize ?
                        //nz(Brick1[1]) - BrickSize
                            //: nz(Brick1[1]))


Brick1() =>
    s1 = 0.0
    s1 := close > nz(s1[1]) + BrickSize ? nz(s1[1]) + BrickSize : 
       close < nz(s1[1]) - BrickSize ? nz(s1[1]) - BrickSize : nz(s1[1])
    s1


Brick2() =>
    s2 = 0.0
    Brick1_1 = Brick1()
    s2 := Brick1() != Brick1()[1] ? Brick1_1[1] : nz(s2[1])
    s2

colorer = Brick1() > Brick2() ? color.green : color.red
p1 = plot(Brick1(), color=colorer, linewidth=4, title="Renko")
p2 = plot(Brick2(), color=colorer, linewidth=4, title="Renko")
fill(p1, p2, color=color.purple, transp=50)




mylong = crossover(Brick1(), Brick2())
myshort = crossunder(Brick1(), Brick2())

last_long = float(na)
last_short = float(na)
last_long := mylong ? time : nz(last_long[1])
last_short := myshort ? time : nz(last_short[1])

in_long = last_long > last_short ? 2 : 0
in_short = last_short > last_long ? 2 : 0

mylong2 = crossover(Brick1(), Brick2())
myshort2 = crossunder(Brick1(), Brick2())

last_long2 = float(na)
last_short2 = float(na)
last_long2 := mylong2 ? time : nz(last_long2[1])
last_short2 := myshort2 ? time : nz(last_short2[1])

in_long2 = last_long2 > last_short2 ? 0 : 0
in_short2 = last_short2 > last_long2 ? 0 : 0


condlongx = in_long + in_long2
condlong = crossover(condlongx, 1.9)
condlongclose = crossunder(condlongx, 1.9)

condshortx = in_short + in_short2
condshort = crossover(condshortx, 1.9)
condshortclose = crossunder(condshortx, 1.9)


// === STRATEGY - LONG POSITION EXECUTION WITH CLOSE ORDERS ===
//enterLong() => crossover(condlongx, 1.9) and testPeriod() and strategy.position_size <= 0
//exitLong()  => crossunder(condlongx, 1.9) and testPeriod() and strategy.position_size > 0
//strategy.entry(id = "Long", long = true, when = enterLong())
//strategy.close(id = "Long", when = exitLong())
// === STRATEGY - SHORT POSITION EXECUTION WITH CLOSE ORDER===
//enterShort() => crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0 and Margin
//exitShort() => crossunder(condshortx, 1.9)  and testPeriod() and strategy.position_size < 0
//strategy.entry(id = "Short", long = false, when = enterShort())
//strategy.close(id = "Short", when = exitShort())   
//END


///STRATEGY ONLY LONG AND SHORT/////
if crossover(condlongx, 1.9) and testPeriod() and strategy.position_size <= 0
    strategy.entry("Long", strategy.long, comment="Long")

if crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0
    strategy.close("Long", when=not Margin)

if crossover(condshortx, 1.9) and testPeriod() and strategy.position_size >= 0
    strategy.entry("Short", strategy.short, comment="Short", when=Margin)

/////// END ////

Mehr