In einem früheren Artikel.https://www.fmz.com/digest-topic/4187Wir haben die Pairing Trading Strategie vorgestellt und demonstriert, wie man mit Hilfe von Daten und mathematischen Analysen Handelsstrategien erstellt und automatisiert.

Die Multi-Space Equilibrium-Strategie ist eine natürliche Erweiterung der Pairing-Trading-Strategie, die für einen Basket-Trading-Index gilt. Sie ist insbesondere für verschiedene und miteinander verknüpfte Handelsmärkte wie den Digital-Money-Markt und den Commodity-Futures-Markt geeignet.

Grundprinzipien

Die Multi-Space-Equilibrium-Strategie ist eine Strategie, bei der sowohl Multi als auch Multi-Basket-Trading durchgeführt wird. Ähnlich wie bei Pairing-Trading wird festgestellt, welche Anlage billiger und welche teurer ist. Anders ist es, dass die Multi-Space-Equilibrium-Strategie alle Anlagen in einem ausgewählten Aktienpool sortiert, um festzustellen, welche Anlagen relativ billig oder teuer sind.

Erinnern Sie sich, dass wir zuvor gesagt haben, dass Pairing-Trading eine marktneutrale Strategie ist? Das gilt auch für die Multiplatz-Gleichgewichtsstrategie, da die Multiplatz- und die Multiplatz-Ebenheit sicherstellt, dass die Strategie marktneutral bleibt ("unbeeinflusst von Marktfluktuationen"). Die Strategie ist auch statistisch solide; durch das Ranking von Anleihen und das Halten mehrerer Positionen können Sie mehrere Positionen in Ihr Rankingmodell einnehmen, anstatt nur ein einmaliges Risiko einzunehmen.

Was ist ein Ranking-Programm?

Ein Ranking-System ist ein Modell, in dem die Priorität für jede Investitionsmarke auf der Grundlage der erwarteten Performance zugeordnet werden kann. Die Faktoren können Wertfaktoren, technische Indikatoren, Preismodelle oder eine Kombination von allen oben genannten Faktoren sein. Zum Beispiel können Sie Dynamik-Indikatoren verwenden, um eine Reihe von Trends zu verfolgen, um Investitionsmarken zu rangieren: Die Investitionsmarke mit der höchsten Dynamik wird voraussichtlich weiterhin gut abschneiden und die höchste Rangliste erhalten; die Investitionen mit der geringsten Dynamik werden am schlechtesten und mit der niedrigsten Rendite abschneiden.

Der Erfolg dieser Strategie liegt fast ausschließlich in der Verwendung eines Ranking-Systems, bei dem Ihre Ranking-Systems die Strategien für mehrere leere Anlagemarken besser realisieren können, indem sie die Hoch- und die Niedrigperformance-Investments trennen. Daher ist es wichtig, ein Ranking-System zu entwickeln.

Wie wird ein Ranking-Programm entwickelt?

Sobald wir das Ranking-System festgelegt haben, wollen wir natürlich davon profitieren. Wir tun dies, indem wir die gleichen Mittel in mehrere Ranking-Investitionen investieren, die an der Spitze der Rangliste stehen, und die an der Unterseite der Rangliste liegen. Dies stellt sicher, dass die Strategie nur proportional zur Qualität der Rangliste verdient und "marktneutral" ist.

Nehmen wir an, Sie bewerten alle Anlagezeichen m, haben eine Investition von n US-Dollar und möchten Positionen mit insgesamt 2p (von denen m> 2p) halten. Wenn die Anlagezeichen mit Rang 1 am schlechtesten erwartet werden, wird die Anlagezeichen mit Rang m am besten erwartet:

• Sie haben die Markierung in einer Position angeordnet wie: 1,..., p, und Sie machen die Markierung von 2 / 2p Dollar frei.

• Sie haben die Markierung so angeordnet: m-p,..., m in einer Position, die mehr als n/2p Dollar ist.

** Hinweis: ** Da die Preise für die durch Preissprünge verursachten Investitionsmarken nicht immer gleichmäßig aufgeteilt werden n/2p und man bestimmte Investitionsmarken in ganzen Zahlen kaufen muss, gibt es einige ungenaue Algorithmen, die so nah wie möglich an diese Zahl kommen sollten. Für die Strategien, die n = 100000 und p = 500 laufen, sehen wir:

n/2p = 100000/1000 = 100

Dies ist ein großes Problem für Preise mit einem Wert von mehr als 100 (z. B. auf den Kommoditäts-Futures-Märkten), da man keine Positionen mit einem Wert von mehr als 100 (wie in den digitalen Währungsmärkten nicht) aufnehmen kann. Wir mildern dies durch eine Verringerung des Preissatzes oder eine Erhöhung des Kapitals.

Lassen Sie uns ein Hypothesenbeispiel betrachten.

• Wir bauen unsere Forschungsumgebung auf der Quantifizierungsplattform für Erfinder.

Zunächst einmal müssen wir unsere Forschungsumgebung bauen, um die Arbeit reibungslos durchführen zu können, und in diesem Artikel nutzen wir die Quantifizierungsplattform der Erfinder.FMZ.COMDie Entwicklung von Docker-Systemen, die für die Entwicklung von Docker-Systemen verwendet werden, wurde in der Vergangenheit in der Forschung durchgeführt, vor allem für eine einfache und schnelle API-Schnittstelle und ein vollständiges Docker-System.

In der offiziellen Bezeichnung der Quantifizierungsplattform der Erfinder wird das Docker-System als Host-System bezeichnet.

Über die Implementierung von Administratoren und Roboter lesen Sie in meinem früheren Artikel:https://www.fmz.com/bbs-topic/4140

Leser, die sich einen Cloud-Deployment-Manager kaufen möchten, können sich an diesen Artikel wenden:https://www.fmz.com/bbs-topic/2848

Nachdem wir einen guten Cloud-Dienst und ein gutes Administrator-System erfolgreich bereitgestellt haben, werden wir nun den größten Templar von Python installieren: Anaconda

Der einfachste Weg, um alle hierfür notwendigen Programmierumgebungen (Dependenzen, Versionsmanagement usw.) zu realisieren, ist Anaconda.

Über die Installation von Anaconda lesen Sie im offiziellen Anaconda-Handbuch:https://www.anaconda.com/distribution/

本文还将用到numpy和pandas这两个目前在Python科学计算方面十分流行且重要的库.

Diese grundlegenden Arbeiten können auch auf meinen früheren Artikel über die Einrichtung der Anaconda-Umgebung und der Bibliotheken numpy und pandas zurückgeführt werden:https://www.fmz.com/digest-topic/4169

Wir erzeugen zufällige Investitionswerte und zufällige Faktoren, die wir einordnen. Nehmen wir an, dass unsere zukünftige Rendite tatsächlich von diesen Faktoren abhängt.

import numpy as np
import statsmodels.api as sm
import scipy.stats as stats
import scipy
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
## PROBLEM SETUP ##
# Generate stocks and a random factor value for them
stock_names = ['stock ' + str(x) for x in range(10000)]
current_factor_values = np.random.normal(0, 1, 10000)
# Generate future returns for these are dependent on our factor values
future_returns = current_factor_values + np.random.normal(0, 1, 10000)
# Put both the factor values and returns into one dataframe
data = pd.DataFrame(index = stock_names, columns=['Factor Value','Returns'])
data['Factor Value'] = current_factor_values
data['Returns'] = future_returns
# Take a look
data.head(10)

Jetzt, da wir Faktorwert und Ertrag haben, können wir sehen, was passiert, wenn wir die Anlage nach Faktorwert ranken, und dann die Multi- und Leerposition eröffnen.

# Rank stocks
ranked_data = data.sort_values('Factor Value')
# Compute the returns of each basket with a basket size 500, so total (10000/500) baskets
number_of_baskets = int(10000/500)
basket_returns = np.zeros(number_of_baskets)
for i in range(number_of_baskets):
    start = i * 500
    end = i * 500 + 500 
    basket_returns[i] = ranked_data[start:end]['Returns'].mean()
# Plot the returns of each basket
plt.figure(figsize=(15,7))
plt.bar(range(number_of_baskets), basket_returns)
plt.ylabel('Returns')
plt.xlabel('Basket')
plt.legend(['Returns of Each Basket'])
plt.show()

Unsere Strategie besteht darin, mehr als einen Platz in einem Pool von Investitionswerten zu haben; nur Platz 10 zu haben. Die Belohnung für diese Strategie ist:

basket_returns[number_of_baskets-1] - basket_returns[0]

Das Ergebnis ist: 4.172.

Wir setzen das Geld in unser Ranking-Modell, um es von den schlechten und den guten Anlegern zu trennen.

In den folgenden Teilen dieses Artikels werden wir darüber sprechen, wie man Ranking-Systeme bewerten kann. Der Vorteil von Ranking-basierter Gewinnspanne liegt darin, dass sie nicht von der Marktunordnung beeinflusst wird, sondern von ihr profitiert werden kann.

Wir wollen uns ein Beispiel aus der realen Welt anschauen.

Wir laden die Daten für 32 Aktien aus verschiedenen Branchen des S&P 500 hoch und versuchen, sie zu ranken.

from backtester.dataSource.yahoo_data_source import YahooStockDataSource
from datetime import datetime
startDateStr = '2010/01/01'
endDateStr = '2017/12/31'
cachedFolderName = '/Users/chandinijain/Auquan/yahooData/'
dataSetId = 'testLongShortTrading'
instrumentIds = ['ABT','AKS','AMGN','AMD','AXP','BK','BSX',
                'CMCSA','CVS','DIS','EA','EOG','GLW','HAL',
                'HD','LOW','KO','LLY','MCD','MET','NEM',
                'PEP','PG','M','SWN','T','TGT',
                'TWX','TXN','USB','VZ','WFC']
ds = YahooStockDataSource(cachedFolderName=cachedFolderName,
                            dataSetId=dataSetId,
                            instrumentIds=instrumentIds,
                            startDateStr=startDateStr,
                            endDateStr=endDateStr,
                            event='history')
price = 'adjClose'

Lassen Sie uns die Standardisierte Dynamik-Anzeige für einen Monatszyklus als Basis für die Rangliste verwenden.

## Define normalized momentum
def momentum(dataDf, period):
    return dataDf.sub(dataDf.shift(period), fill_value=0) / dataDf.iloc[-1]
## Load relevant prices in a dataframe
data = ds.getBookDataByFeature()[‘Adj Close’]
#Let's load momentum score and returns into separate dataframes
index = data.index
mscores = pd.DataFrame(index=index,columns=assetList)
mscores = momentum(data, 30)
returns = pd.DataFrame(index=index,columns=assetList)
day = 30

Jetzt werden wir das Verhalten unserer Aktien analysieren, um zu sehen, wie unsere Aktien in den Märkten unter unseren gewählten Rangfaktoren funktionieren.

Daten analysieren

Aktienverhalten

Wir sehen, wie sich die von uns gewählten Waren in unserem Rankingmodell verhalten. Dafür berechnen wir die langfristige Rendite aller Aktien für eine Woche. Dann können wir die Korrelation zwischen der Rendite der einzelnen Aktien vor einer Woche und der Dynamik der vorherigen 30 Tage betrachten.

# Calculate Forward returns
forward_return_day = 5
returns = data.shift(-forward_return_day)/data -1
returns.dropna(inplace = True)
# Calculate correlations between momentum and returns
correlations = pd.DataFrame(index = returns.columns, columns = [‘Scores’, ‘pvalues’])
mscores = mscores[mscores.index.isin(returns.index)]
for i in correlations.index:
    score, pvalue = stats.spearmanr(mscores[i], returns[i])
    correlations[‘pvalues’].loc[i] = pvalue
    correlations[‘Scores’].loc[i] = score
correlations.dropna(inplace = True)
correlations.sort_values(‘Scores’, inplace=True)
l = correlations.index.size
plt.figure(figsize=(15,7))
plt.bar(range(1,1+l),correlations[‘Scores’])
plt.xlabel(‘Stocks’)
plt.xlim((1, l+1))
plt.xticks(range(1,1+l), correlations.index)
plt.legend([‘Correlation over All Data’])
plt.ylabel(‘Correlation between %s day Momentum Scores and %s-day forward returns by Stock’%(day,forward_return_day));
plt.show()

Alle unsere Aktien sind in gewissem Maße gleichwertig zurückgegangen! (Offensichtlich funktioniert das Universum, das wir gewählt haben so) Das sagt uns, dass wenn eine Aktie in der Dynamik-Analyse eine hohe Rangliste erzielt, wir sie für die nächste Woche schlecht erwarten sollten.

Relation zwischen Leistung und Leistung bei der Dynamikanalyse

Als nächstes müssen wir die Korrelation zwischen unserem Ranking-Score und den nachfolgenden Erträgen des gesamten Marktes betrachten, also die Beziehung zwischen der voraussichtlichen Ertragsrate und unseren Ranking-Faktoren, ob eine höhere Relevanzstufe eine schlechtere relative Ertragsrate voraussagt oder umgekehrt.

Zu diesem Zweck berechnen wir die tägliche Korrelation zwischen der 30-Tage-Bewegung aller Aktien und der einwöchigen langfristigen Rendite.

correl_scores = pd.DataFrame(index = returns.index.intersection(mscores.index), columns = [‘Scores’, ‘pvalues’])
for i in correl_scores.index:
    score, pvalue = stats.spearmanr(mscores.loc[i], returns.loc[i])
    correl_scores[‘pvalues’].loc[i] = pvalue
    correl_scores[‘Scores’].loc[i] = score
correl_scores.dropna(inplace = True)
l = correl_scores.index.size
plt.figure(figsize=(15,7))
plt.bar(range(1,1+l),correl_scores[‘Scores’])
plt.hlines(np.mean(correl_scores[‘Scores’]), 1,l+1, colors=’r’, linestyles=’dashed’)
plt.xlabel(‘Day’)
plt.xlim((1, l+1))
plt.legend([‘Mean Correlation over All Data’, ‘Daily Rank Correlation’])
plt.ylabel(‘Rank correlation between %s day Momentum Scores and %s-day forward returns’%(day,forward_return_day));
plt.show()

Die tägliche Korrelation zeigt sich sehr laut, aber sehr leicht (das ist zu erwarten, da wir gesagt haben, dass alle Aktien gleichwertig zurückkehren).

monthly_mean_correl =correl_scores['Scores'].astype(float).resample('M').mean()
plt.figure(figsize=(15,7))
plt.bar(range(1,len(monthly_mean_correl)+1), monthly_mean_correl)
plt.hlines(np.mean(monthly_mean_correl), 1,len(monthly_mean_correl)+1, colors='r', linestyles='dashed')
plt.xlabel('Month')
plt.xlim((1, len(monthly_mean_correl)+1))
plt.legend(['Mean Correlation over All Data', 'Monthly Rank Correlation'])
plt.ylabel('Rank correlation between %s day Momentum Scores and %s-day forward returns'%(day,forward_return_day));
plt.show()

Wir können sehen, dass die durchschnittliche Korrelation wieder etwas negativ ist, aber auch sehr stark von Monat zu Monat ändert sich.

Durchschnittliche Aktienrendite

Wir haben die Rendite für einen Korb von Aktien berechnet, die aus unserer Rangliste entfernt wurden. Wenn wir alle Aktien auflisten und sie in n Gruppen aufteilen, was ist der durchschnittliche Ertrag für jede Gruppe?

Der erste Schritt besteht darin, eine Funktion zu erstellen, die die durchschnittliche Rendite und den Rangfaktor für jeden bestimmten Korb pro Monat gibt.

def compute_basket_returns(factor, forward_returns, number_of_baskets, index):
data = pd.concat([factor.loc[index],forward_returns.loc[index]], axis=1)
    # Rank the equities on the factor values
    data.columns = ['Factor Value', 'Forward Returns']
    data.sort_values('Factor Value', inplace=True)
    # How many equities per basket
    equities_per_basket = np.floor(len(data.index) / number_of_baskets)
basket_returns = np.zeros(number_of_baskets)
# Compute the returns of each basket
    for i in range(number_of_baskets):
        start = i * equities_per_basket
        if i == number_of_baskets - 1:
            # Handle having a few extra in the last basket when our number of equities doesn't divide well
            end = len(data.index) - 1
        else:
            end = i * equities_per_basket + equities_per_basket
        # Actually compute the mean returns for each basket
        #s = data.index.iloc[start]
        #e = data.index.iloc[end]
        basket_returns[i] = data.iloc[int(start):int(end)]['Forward Returns'].mean()
        
    return basket_returns

Wir berechnen die durchschnittliche Rendite pro Korb, wenn wir die Aktien mit dieser Punktzahl bewerten. Dies sollte uns eine Vorstellung von ihrer Beziehung über einen langen Zeitraum geben.

number_of_baskets = 8
mean_basket_returns = np.zeros(number_of_baskets)
resampled_scores = mscores.astype(float).resample('2D').last()
resampled_prices = data.astype(float).resample('2D').last()
resampled_scores.dropna(inplace=True)
resampled_prices.dropna(inplace=True)
forward_returns = resampled_prices.shift(-1)/resampled_prices -1
forward_returns.dropna(inplace = True)
for m in forward_returns.index.intersection(resampled_scores.index):
    basket_returns = compute_basket_returns(resampled_scores, forward_returns, number_of_baskets, m)
    mean_basket_returns += basket_returns
mean_basket_returns /= l    
print(mean_basket_returns)
# Plot the returns of each basket
plt.figure(figsize=(15,7))
plt.bar(range(number_of_baskets), mean_basket_returns)
plt.ylabel('Returns')
plt.xlabel('Basket')
plt.legend(['Returns of Each Basket'])
plt.show()

Es scheint, dass wir die Hoch- und die Niedrigqualifizierten trennen können.

Gewinndifferenz (Key) Konsistenz

Natürlich sind das nur die Durchschnittsverhältnisse. Um zu verstehen, wie konsistent diese Beziehung ist und ob wir bereit sind, zu handeln, sollten wir unsere Art und Weise und unsere Einstellung zu ihr im Laufe der Zeit ändern.

total_months = mscores.resample('M').last().index
months_to_plot = 24
monthly_index = total_months[:months_to_plot+1]
mean_basket_returns = np.zeros(number_of_baskets)
strategy_returns = pd.Series(index = monthly_index)
f, axarr = plt.subplots(1+int(monthly_index.size/6), 6,figsize=(18, 15))
for month in range(1, monthly_index.size):
    temp_returns = forward_returns.loc[monthly_index[month-1]:monthly_index[month]]
    temp_scores = resampled_scores.loc[monthly_index[month-1]:monthly_index[month]]
    for m in temp_returns.index.intersection(temp_scores.index):
        basket_returns = compute_basket_returns(temp_scores, temp_returns, number_of_baskets, m)
        mean_basket_returns += basket_returns
    
    strategy_returns[monthly_index[month-1]] = mean_basket_returns[ number_of_baskets-1] - mean_basket_returns[0]
    
    mean_basket_returns /= temp_returns.index.intersection(temp_scores.index).size
    
    r = int(np.floor((month-1) / 6))
    c = (month-1) % 6
    axarr[r, c].bar(range(number_of_baskets), mean_basket_returns)
    axarr[r, c].xaxis.set_visible(False)
    axarr[r, c].set_title('Month ' + str(month))
plt.show()

plt.figure(figsize=(15,7))
plt.plot(strategy_returns)
plt.ylabel(‘Returns’)
plt.xlabel(‘Month’)
plt.plot(strategy_returns.cumsum())
plt.legend([‘Monthly Strategy Returns’,’Cumulative Strategy Returns’])
plt.show()

Wenn wir also den letzten Korb machen und jeden Monat den ersten Korb freimachen, dann sehen wir uns die Rendite an (vorausgesetzt, dass die Kapitalverteilung für jede Wertpapier gleich ist).

total_return = strategy_returns.sum()
ann_return = 100*((1 + total_return)**(12.0 /float(strategy_returns.index.size))-1)
print('Annual Returns: %.2f%%'%ann_return)

Jahresrendite: 5,03%

Wir sehen, dass wir eine sehr schwache Rangliste haben, die nur moderat zwischen Hoch- und Niedrigperformer-Aktien unterscheidet. Außerdem ist die Rangliste nicht konsistent und ändert sich stark von Monat zu Monat.

Finden Sie die richtigen Ranglisten

Um eine Plural Balancing-Ranking-Strategie zu realisieren, musst du eigentlich nur ein Ranking-System festlegen. Alles danach ist mechanisch. Sobald du eine Plural Balancing-Ranking-Strategie hast, kannst du verschiedene Ranking-Faktoren austauschen, ohne dass sonst viel geändert wird.

Rankings können auch aus nahezu jedem Modell stammen. Es muss nicht ein wertbasiertes Faktormodell sein, sondern eine Art von Machine-Learning-Technik, die die Rendite einen Monat im Voraus prognostiziert und nach dieser Rangfolge rangiert.

Auswahl und Bewertung der Rangliste

Die Rangliste ist der Vorteil und der wichtigste Bestandteil einer Strategie des Mehrfach-Gleichgewichts. Die Wahl einer guten Rangliste ist ein systematisches Vorhaben und es gibt keine einfachen Antworten.

Ein guter Ausgangspunkt ist die Auswahl bekannter Technologien, um zu sehen, ob man sie leicht modifizieren kann, um höhere Renditen zu erzielen.

• Klonen und AnpassenWählen Sie ein oft diskutiertes Thema aus und sehen Sie, ob Sie es leicht ändern können, um einen Vorteil zu erzielen. In der Regel werden die offenen Faktoren keine Handelssignale mehr haben, da sie vollständig aus dem Markt profitiert haben.

• Preismodell: Jedes Modell, das zukünftige Erträge prognostiziert, kann ein Faktor sein, der potenziell für die Rangliste Ihrer Handelszeichen in einem Korb verwendet werden kann.

• Preisbasierte Faktoren (technische Indikatoren): Preis-basierte Faktoren, wie wir sie heute diskutieren, erhalten Informationen über die historischen Preise für jedes Anspruchs und verwenden sie, um Faktorenwerte zu erzeugen. Beispiele können beispielsweise ein gleitender Durchschnitt, ein Dynamikindikator oder ein Volatilitätsindikator sein.

• Regression und BewegungEs ist bemerkenswert, dass einige Faktoren behaupten, dass die Preise, sobald sie sich in eine Richtung entwickelt haben, weiter so werden. Andere Faktoren sind genau umgekehrt. Beide sind effektive Modelle für verschiedene Zeitspannen und Vermögenswerte, und es ist wichtig, zu untersuchen, ob das grundlegende Verhalten dynamisch oder regressiv ist.

• Grundfaktoren (wertbasiert)Das ist eine Kombination von Basiswerten, wie PE, Dividenden usw. Basiswerten enthalten Informationen, die mit den realen Fakten der Firma zusammenhängen, und können daher in vielen Punkten stärker sein als der Preis.

Letztendlich ist die Prognose von Wachstumsfaktoren ein Rüstungsrennen, in dem Sie versuchen, einen Schritt voraus zu bleiben. Faktoren werden aus dem Markt abgezogen und haben eine Lebensdauer, so dass Sie ständig arbeiten müssen, um festzustellen, wie viel Depression Ihre Faktoren erlebt haben und welche neuen Faktoren verwendet werden können, um sie zu ersetzen.

Weitere Überlegungen

• Frequenz wieder ausgleichen

Jedes Ranking-System prognostiziert die Rendite in einem etwas anderen Zeitrahmen. Eine preisbasierte Mittelwert-Rückkehr kann in wenigen Tagen prognostiziert werden, während ein wertbasiertes Faktormodell in einigen Monaten prognostiziert werden kann. Es ist wichtig, den Zeitrahmen zu bestimmen, in dem das Modell prognostizieren soll, und eine statistische Verifizierung vor der Ausführung der Strategie durchzuführen.

• Kapitalfähigkeit und Transaktionskosten

Jede Strategie hat ein Minimum und ein Maximum an Kapitalvolumen, wobei die Mindestgrenze in der Regel durch die Transaktionskosten bestimmt wird.

Zu viele Aktien zu handeln, führt zu hohen Transaktionskosten. Angenommen, Sie wollen 1000 Aktien kaufen, dann werden Sie jedes Mal ein paar Tausend Dollar kosten. Ihre Kapitalbasis muss hoch genug sein, dass die Transaktionskosten einen kleinen Teil der Rendite ausmachen, die Ihre Strategie erzeugt. Zum Beispiel, wenn Sie 100.000 Dollar haben und Ihre Strategie monatlich 1% verdient (z. B. 1.000 Dollar), werden all diese Renditen von den Transaktionskosten eingenommen.

Das ist der Fall, weil die Strategie relativ selten wieder ausgeglichen wird. Die Gesamtvermögen wird außer der Anzahl der gehandelten Aktien sehr niedrig sein, und der Dollarwert jeder Aktie ist so niedrig, dass Sie sich keine Sorgen machen müssen, dass Ihr Handelsaufkommen den Markt beeinflusst. Nehmen wir an, Sie handeln 1000 Aktien, das sind 100.000.000 USD.