
Die Strategie basiert auf dem Mondphasenzyklus als Handelssignal und identifiziert Handelschancen für digitale Währungen wie Bitcoin in Kombination mit mehreren Indikatoren wie RSI, MACD und OBV. Der Hauptvorteil der Strategie besteht darin, dass der Mondphasenzyklus als externe Faktor als Handelssignal genutzt wird. Im Gegensatz zu den meisten Strategien, die nur auf technische Indikatoren angewiesen sind, kann die Marktmanipulation zu einem gewissen Grad vermieden werden.
Die Kernlogik dieser Strategie ist, dass die verschiedenen Phasen des Mondphasenzyklus die Voraussetzungen für eine Über- oder Unterzahlung erfüllen. Die Formel zur Berechnung der Mondphasen lautet:
Die Länge des Mondphasenzyklus = 29.5305882 Tage Die Anzahl der Tage, die von einem bekannten Vollmond bis zur gegenwärtigen Zeit liegen Alter der Mondphase = Anzahl der Tage bis zur bekannten Vollmondphase prozentuale Länge der Mondphasenzyklus Monatsphasenwert = 1 + cos (Monatsphasenalter / Monatsphasenzykluslänge)*2*π))/2
Die Größe des Mondphasenwertes kann die aktuelle Mondphase bestimmen. Die Mondphase variiert zwischen 0 und 1, je größer der Wert ist, desto näher ist der Vollmond und je kleiner der Wert, desto näher ist der Neumond.
Die Strategie entscheidet, ob die Monatsphasen-Durchschnittswerte für die Über- oder Unterbrechungssituation geeignet sind. Wenn die Monatsphasen-Durchschnittswerte größer sind als die Über- oder Unterbrechungssituation (Standard: 0.51), gibt es eine Chance, mehr zu machen; wenn die Monatsphasen-Durchschnittswerte kleiner sind als die Unterbrechungssituation (Standard: 0.49), gibt es eine Chance, zu machen.
Die Strategie kombiniert außerdem Indicatoren wie Handelsvolumen, RSI und MACD, um Handelssignale in nicht idealen Situationen zu vermeiden. Positionen werden nur geöffnet, wenn der Handelsvolumen steigt und der RSI und der MACD entsprechen.
Diese Strategie hat folgende Vorteile:
Insgesamt nutzt die Strategie die einzigartigen Vorteile der Mondphase und wird durch verschiedene technische Indikatoren unterstützt, um hochprobable Handelschancen zu identifizieren und das Handelsrisiko durch Risikokontrollen effektiv zu kontrollieren.
Diese Strategie birgt folgende Risiken:
Um diese Risiken zu kontrollieren, können folgende Maßnahmen ergriffen werden:
Durch die Optimierung der Parameter und die Anwendung von Komplexindikatoren kann das Handelsrisiko weitgehend vermieden werden.
Die Strategie kann noch weiter optimiert werden:
Diese Strategie ermöglicht den effizienten Handel mit Bitcoin durch einzigartige Handelssignale in Monatsphasen und in Verbindung mit Mainstream-Technologie-Indikatoren. Im Vergleich zu einer Strategie mit einem einzigen Indikator ist diese Strategie besser gegen das Risiko von Marktmanipulationen geschützt und hat einen einzigartigen Vorteil. Durch die Verringerung der Risiken und die Optimierung der Parameter können beständig bessere Erträge erzielt werden.
/*backtest
start: 2023-01-08 00:00:00
end: 2024-01-14 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
strategy("Lunar Phase Strategy by Symphoenix", overlay=true)
// Input parameters
start_year = input(2023, title="Start year")
end_year = input(2023, title="End year")
longPhaseThreshold = input(0.51, title="Long Phase Threshold")
shortPhaseThreshold = input(0.49, title="Short Phase Threshold")
riskPerTrade = input(0.05, title="Risk Per Trade (as a % of Equity)")
stopLossPerc = input(0.01, title="Stop Loss Percentage")
atrLength = input(21, title="ATR Length for Volatility")
trailPerc = input(0.1, title="Trailing Stop Percentage")
maxDrawdownPerc = input(0.1, title="Maximum Drawdown Percentage")
volumeLength = input(7, title="Volume MA Length")
// Constants for lunar phase calculation and ATR
atr = ta.atr(atrLength)
volMA = ta.sma(volume, volumeLength) // Volume moving average
// Improved Lunar Phase Calculation
calculateLunarPhase() =>
moonCycleLength = 29.5305882
daysSinceKnownFullMoon = (time - timestamp("2019-12-12T05:12:00")) / (24 * 60 * 60 * 1000)
lunarAge = daysSinceKnownFullMoon % moonCycleLength
phase = ((1 + math.cos(lunarAge / moonCycleLength * 2 * math.pi)) / 2)
phase
lunarPhase = calculateLunarPhase()
// Advanced Volume Analysis
priceChange = ta.change(close)
obv = ta.cum(priceChange > 0 ? volume : priceChange < 0 ? -volume : 0)
// Additional Technical Indicators
rsi = ta.rsi(close, 14)
[macdLine, signalLine, _] = ta.macd(close, 12, 26, 9)
// Calculate Position Size based on Volatility and Account Equity
calculatePositionSize() =>
equity = strategy.equity
riskAmount = equity * riskPerTrade
positionSize = riskAmount / atr
if positionSize > 1000000000000
positionSize := 1000000000000
positionSize
positionSize = calculatePositionSize()
// Maximum Drawdown Tracking
var float maxPortfolioValue = na
maxPortfolioValue := math.max(maxPortfolioValue, strategy.equity)
drawdown = (maxPortfolioValue - strategy.equity) / maxPortfolioValue
// Check for maximum drawdown
if drawdown > maxDrawdownPerc
strategy.close_all()
strategy.cancel_all()
// Volume Analysis
isVolumeConfirmed = volume > volMA
// Date Check for Backtesting Period
isWithinBacktestPeriod = year >= start_year and year <= end_year
// Entry and Exit Conditions
// Adjusted Entry and Exit Conditions
longCondition = lunarPhase > longPhaseThreshold and lunarPhase < 0.999 and isVolumeConfirmed and obv > obv[1] and rsi < 70 and macdLine > signalLine and isWithinBacktestPeriod
shortCondition = lunarPhase < shortPhaseThreshold and lunarPhase > 0.001 and isVolumeConfirmed and obv < obv[1] and rsi > 30 and macdLine < signalLine and isWithinBacktestPeriod
if longCondition
if strategy.position_size < 0
strategy.close_all()
if strategy.position_size < positionSize
strategy.entry("Long", strategy.long, qty=positionSize)
strategy.exit("Exit Long", "Long", trail_offset=atr * trailPerc, trail_points=atr)
if shortCondition
if strategy.position_size > 0
strategy.close_all()
if strategy.position_size > -positionSize
strategy.entry("Short", strategy.short, qty=positionSize)
strategy.exit("Exit Short", "Short", trail_offset=atr * trailPerc, trail_points=atr)
// Implementing Stop-Loss Logic
longStopLoss = strategy.position_avg_price * (1 - stopLossPerc)
shortStopLoss = strategy.position_avg_price * (1 + stopLossPerc)
if strategy.position_size > 0 and close < longStopLoss
strategy.close("Long")
if strategy.position_size < 0 and close > shortStopLoss
strategy.close("Short")