Die Ressourcen sind geladen. Beförderung...

Dynamische Positionsaufbaustrategie

Schriftsteller:ChaoZhang, Datum: 2024-02-20 14:16:30
Tags:

Übersicht

Die Hauptidee dieser Strategie besteht darin, dynamisch eine Position auf der Grundlage von Systemsignalen in einem Bullenmarkt aufzubauen, um Risiken zu kontrollieren und einen niedrigeren durchschnittlichen Einstiegspreis zu erzielen.

Strategie Logik

Die Strategie legt zunächst das Startkapital und den DCA-Prozentsatz fest. Beim Schließen jedes Balkens berechnet sie einen angepassten Prozentsatz basierend auf der Preisänderung. Wenn der Preis steigt, senkt sie den Prozentsatz. Wenn der Preis fällt, erhöht sie den Prozentsatz. Dies ermöglicht es, die Position zu niedrigeren Preisen hinzuzufügen. Sie berechnet dann die Auftragsgröße basierend auf dem angepassten Prozentsatz und dem verbleibenden Kapital. Beim Schließen jedes Balkens platziert sie Aufträge, die Position aufzubauen, bis das Startkapital aufgebraucht ist.

So kann es Risiken kontrollieren und einen niedrigeren durchschnittlichen Einstiegspreis bei schwankender Preisbewegung erzielen.

Analyse der Vorteile

Die Strategie weist folgende Vorteile auf:

Es kann dynamisch in der Position skaliert werden, die Zuteilung bei Einfällen erhöht und die Zuteilung bei Erhebungen verringert, um Risiken zu kontrollieren.
Es erhält einen niedrigeren Durchschnitts-Eingangspreis im Vergleich zum Medianpreis, was mehr Gewinnpotenzial ermöglicht.
Es passt zu bullischen Märkten mit Volatilität für bessere Risiko-Rendite-Ratio.
Sie ermöglicht die Voreinstellung von Startkapital und DCA-Prozentsatz, um das Positionsgrößenrisiko zu kontrollieren.
Es liefert Statistiken über den durchschnittlichen Einstiegspreis und den Medianpreis, um die Einstiegsqualität eindeutig beurteilen zu können.

Risikoanalyse

Es gibt auch einige Risiken:

Wenn die Märkte abstürzen, wird sich die Position immer weiter vergrößern, was zu hohen Verlusten führt.
Wenn der Kurs schnell steigt, wird die Skalierung abnehmen, möglicherweise verpasst viel von der Rallye.
Eine falsche Parameterkonfiguration birgt ebenfalls Gefahren: Übermäßiges Startkapital und hoher DCA-Prozentsatz vergrößern Verluste.

Optimierungsrichtlinien

Einige Möglichkeiten zur Optimierung der Strategie:

Fügen Sie Stop-Loss-Logik hinzu, um zu vermeiden, dass Sie zu viel verkaufen.
Dynamische Anpassung des DCA-Prozentsatzes auf der Grundlage von Volatilität oder anderen Kennzahlen.
Einbeziehung von Modellen des maschinellen Lernens zur Preisvorhersage und zur Orientierung von Skalierungsentscheidungen.
Kombinieren Sie andere Indikatoren, um Veränderungen der Marktstruktur für die Skalierung von Ausgangspunkten zu ermitteln.
Hinzufügen von Kapitalverwaltungsregeln zu dynamisch vergrößerten Aufträgen auf der Grundlage von Kontowerten.

Schlussfolgerung

Dies ist eine sehr praktische dynamische Positionsscaling-Strategie. Sie passt die Positionsgröße flexibel anhand von Kursschwankungen an, um gute durchschnittliche Eintritte in Bullenmärkte zu erzielen, während das Risiko durch konfigurierbare Parameter eingeschränkt wird. Die Kombination mit anderen Indikatoren oder Modellen kann die Performance weiter verbessern. Sie eignet sich für Anleger, die langfristige Gewinne suchen.

/*backtest
start: 2024-01-20 00:00:00
end: 2024-02-19 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © RWCS_LTD

//@version=5
strategy("DCA IN Calculator {RWCS}", overlay=true, pyramiding=999, default_qty_type=strategy.cash, initial_capital=10000, commission_value=0.02)

// User inputs
backtestStartDate = input(timestamp("1 Jan 2024"), 
     title="Start Date", group="Backtest Time Period",
     tooltip="This start date is in the time zone of the exchange " + 
     "where the chart's instrument trades. It doesn't use the time " + 
     "zone of the chart or of your computer.")
start_date = true
starting_capital = input.float(defval=5000, title="Starting Capital")
dca_allocation_percentage = input.int(defval=10, title="DCA Allocation Percentage")

// Calculate DCA allocation based on price change
price_change_percentage = ((close - close[1]) / close[1]) * 100
adjusted_allocation_percentage = close > close[1] ? dca_allocation_percentage - price_change_percentage : dca_allocation_percentage + price_change_percentage // If price action is negative, increase allocations
adjusted_allocation_percentage1 = dca_allocation_percentage - price_change_percentage // If price action is positive, reduce allocations

// Calculate order size based on adjusted allocation percentage
order_size = (adjusted_allocation_percentage / 100) * starting_capital

// Track remaining capital
var remaining_capital = starting_capital

// Long on the close of every bar
if true
    // Ensure the order size doesn't exceed remaining capital or adjusted allocation
    order_size := math.min(order_size, remaining_capital, adjusted_allocation_percentage / 100 * starting_capital)
    // Ensure order size is not negative
    order_size := math.max(order_size, 0)
    
    strategy.entry("DCA", strategy.long, qty = order_size)
    remaining_capital := remaining_capital - order_size

// Plot average entry price
var float total_entry_price = 0.0
var int total_signals = 0

if start_date
    total_entry_price := total_entry_price + close
    total_signals := total_signals + 1

avg_entry_price = total_entry_price / total_signals

// Calculate and plot median price
var float median_price = na

if start_date
    var float sum_prices = 0.0
    var int num_prices = 0
    
    for i = 0 to bar_index
        if (time[i] >= backtestStartDate)
            sum_prices := sum_prices + close[i]
            num_prices := num_prices + 1
    
    median_price := sum_prices / num_prices

// Reset variables at the start of each day
if (dayofweek != dayofweek[1])
    total_entry_price := 0.0
    total_signals := 0

//table colors
borders_col = color.new(color.black, 90)
top_row_col = color.new(color.gray, 90)
size = input.string(defval='Normal', options=['Tiny', 'Small', 'Normal', 'Large'], title='Table size', inline='design', group='Table Design')
table_size = size == 'Tiny' ? size.tiny : size == 'Small' ? size.small : size == 'Normal' ? size.normal : size == 'Large' ? size.large : na

var tablee = table.new(position=position.top_right, columns=2, rows=3, frame_color=borders_col, frame_width=4, border_color=borders_col, border_width=4)

table.cell(tablee, 0, 0, "Average Entry Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 0, str.tostring(avg_entry_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 1, "Median Price", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 1, str.tostring(median_price, '#.##'), text_color=color.white, text_size=table_size)
table.cell(tablee, 0, 2, "Remaining Capital", bgcolor=top_row_col, text_color=color.white, text_size=table_size)
table.cell(tablee, 1, 2, str.tostring(remaining_capital, '#.##'), text_color=color.white, text_size=table_size)

Mehr