Bessere Werkzeuge machen gute Arbeit - lernen Sie, die Forschungsumgebung zu verwenden, um Handelsprinzipien zu analysieren

Schriftsteller:Lydia., Erstellt: 2022-12-27 16:33:51, Aktualisiert: 2023-09-20 09:17:27

lernen, das Forschungsumfeld zur Analyse von Handelsgrundsätzen zu nutzen

Der Begriff Hedging ist ein sehr grundlegendes Konzept im Bereich des quantitativen Handels und des Programmhandels. Im quantitativen Handel mit digitaler Währung sind die häufig verwendeten Hedging-Strategien: Futures-Spot-Hedging, Cross-Period-Hedging und Spot-Hedging, die im Wesentlichen Transaktionen für Preisunterschiede sind. Vielleicht sind viele Studenten, die gerade in den Bereich des quantitativen Handels eingetreten sind, noch nicht sehr klar, was das Konzept, das Prinzip und die Details des Hedgings sind. Es spielt keine Rolle. Lassen Sie uns das QuantAnalyze-Tool verwenden, das von der FMZ Trading-Plattform zur Verfügung gestellt wird, um dieses Wissen leicht zu erlernen und zu beherrschen.

Klicken Sie im Dashboard der FMZ Quant-Plattform auf Analyze, um auf die Tools-Seite zu klicken:

Hier lade ich die Analysedatei direkt hoch: Dieses Analysepapier ist eine Analyse des Prozesses der Eröffnung und Schließung einer Futures-Spot-Hedging-Position während des Backtestings.quarterDie Spotbörse ist eine OKX-Währungs-Währungs-Transaktion, und das Handelspaar istBTC_USDT. Um den Betriebsprozess der Futures-Spot-Hedging zu analysieren, können Sie die folgende spezifische Forschungsumgebungsdatei sehen, die in zwei Versionen geschrieben ist: eine Python-Version, eine JavaScript-Version.

Forschungsumgebung Python Sprachdatei

Analyse des Grundsatzes der Futures-Spot-Hedging.ipynb In [1]:

from fmz import *
task = VCtx('''backtest
start: 2019-09-19 00:00:00
end: 2019-09-28 12:00:00
period: 15m
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD", "stocks":1}, {"eid":"OKX","currency":"BTC_USDT","balance":10000,"stocks":0}]
''')
# Create backtesting environment
import matplotlib.pyplot as plt
import numpy as np
# Import the plot library matplotlib and library numpy

In [2]:

exchanges[0].SetContractType("quarter")    # The first exchange object OKX Futures (eid: Futures_OKCoin) calls the function to set the current contract as a quarterly contract
initQuarterAcc = exchanges[0].GetAccount() # The initial account information of OKX Futures Exchange is recorded in the variable initQuarterAcc
initQuarterAcc

Ausgeschaltet[2]: {Bilanz: 0,0, FrozenBalance: 0,0, Beständen: 1,0, FrozenBeständen: 0,0}

In [3]:

initSpotAcc = exchanges[1].GetAccount()    # The initial account information of the OKX Spot Exchange is recorded in the variable initSpotAcc
initSpotAcc

Ausgeschaltet[3]: {Bilanz: 10000.0, FrozenBalance: 0.0, Beständen: 0.0, FrozenBeständen: 0.0}

In [4]:

quarterTicker1 = exchanges[0].GetTicker()  # Get the futures exchange ticker, recorded in the variable quarterTicker1
quarterTicker1

Ausgeschaltet[4]: Wir haben uns nicht verändert. High: 10441.25002, Niedrig: 10441.25, Verkauft: 10441.25002, Käufe : 10441.25, Letzte : 10441.25001, Buch : 1772.0, OpenInterest: 0,0}

In [5]:

spotTicker1 = exchanges[1].GetTicker()     # Get the spot exchange ticker, recorded in the variable spotTicker1
spotTicker1

Ausgeschaltet[5]: Wir haben uns nicht verändert. Hoch : 10156.60000002, Niedrig: 10156,6, Verkauft: 10156.60000002, Käufe : 10156.6, Letzte : 10156.60000001, Volume : 7.4443 OpenInterest: 0,0}

In [6]:

quarterTicker1.Buy - spotTicker1.Sell      # The price difference between going short on futures and going long on spot.

Ausgeschaltet[6]: 284,6499999799999985

In [7]:

exchanges[0].SetDirection("sell")                       # Set up a futures exchange and trade in the direction of going short
quarterId1 = exchanges[0].Sell(quarterTicker1.Buy, 10)  # Futures go short to place orders. The order quantity is 10 contracts. The returned order ID is recorded in the variable quarterId1.
exchanges[0].GetOrder(quarterId1)                       # Check the details of the order with futures order ID quarterId1.

Ausgeschaltet[7]: - Ich habe ihn nicht gesehen. Preis : 10441,25, Betrag : 10,0 DealAmount: 10,0, Durchschnittlicher Preis: 10441,25. Typ: 1, Offset: 0, Status : 1, Vertragsart : bQuartal }

In [8]:

spotAmount = 10 * 100 / quarterTicker1.Buy                 # Calculate the currency equivalent of 10 contracts as the order quantity of the spot.
spotId1 = exchanges[1].Buy(spotTicker1.Sell, spotAmount)   # Place orders on the spot exchange
exchanges[1].GetOrder(spotId1)                             # Check the order details of the spot order ID of spotId1

Außen[8]: - Ich habe ihn nicht gesehen. Preis: 10156.60000002, Betrag : 0,0957, DealAmount: 0,0957, Durchschnittlicher Preis: 10156.60000002. Typ: 0, Offset: 0, Status : 1, ContractType: bBTC_USDT_OKX}

Sie können sehen, dass die Aufträge QuarterId1 und SpotId1 vollständig ausgefüllt sind, d. h. die Absicherung offener Positionen abgeschlossen ist.

In [9]:

Sleep(1000 * 60 * 60 * 24 * 7)       # Hold the position for a while and wait for the price difference to become smaller to close the position.

Nach der Wartezeit bereiten Sie sich darauf vor, die Position zu schließen.quarterTicker2, spotTicker2und sie drucken. Die Transaktionsrichtung des Futures-Börsenobjekts ist so eingestellt, dass die Short-Position geschlossen wird:exchanges[0].SetDirection("closesell")einen Auftrag zur Schließung der Position erteilen. Ausdrucken Sie die Einzelheiten des Closing-Positions-Orders, aus denen hervorgeht, dass der Closing-Order abgeschlossen ist und die Closing-Position abgeschlossen ist.

In [10]:

quarterTicker2 = exchanges[0].GetTicker()     # Get the current futures exchange ticker, recorded in the variable quarterTicker2
quarterTicker2

Ausgeschaltet[10]: Wir sind hier, um dich zu treffen. Hoch: 8497.20002, Niedrig: 8497.2, Verkauft: 8497.20002, Käufe: 8497.2, Letzte : 8497.20001, Volumen : 4311.0, OpenInterest: 0,0}

In [11]:

spotTicker2 = exchanges[1].GetTicker()       # Get the current ticker of the spot exchange, recorded in the variable spotTicker2
spotTicker2

Ausgeschaltet[11]: Wir haben uns nicht verändert. High: 8444.70000001, Niedrig: 8444.69999999, Verkauft: 8444.70000001, Käufe: 8444.69999999, Letzte : 8444,7, Volume: 78.6273, OpenInterest: 0,0}

In [12]:

quarterTicker2.Sell - spotTicker2.Buy        # The price difference between closing a short futures position and closing a long spot position.

Ausgeschaltet[12]: 52.5000200100003

In [13]:

exchanges[0].SetDirection("closesell")                   # Set the current trading direction of the futures exchange to close short positions.
quarterId2 = exchanges[0].Buy(quarterTicker2.Sell, 10)   # The futures exchange places an order to close a position and records the order ID to the variable quarterId2.
exchanges[0].GetOrder(quarterId2)                        # Check futures close out order details

Ausgeschieden[13]: - Ich bin nicht derjenige. Preis: 8497.20002, Betrag : 10,0 DealAmount: 10,0, Durchschnittlicher Preis: 8493,95335, Typ: 0, Vergütung: 1, Status : 1, Vertragsart : bQuartal }

In [14]:

spotId2 = exchanges[1].Sell(spotTicker2.Buy, spotAmount) # The spot exchange places an order to close a position and records the order ID, which is recorded to the variable spotId2.
exchanges[1].GetOrder(spotId2)      # Check spot close out order details

Ausgeschaltet[1]: - Ich bin nicht derjenige. Preis: 8444,69999999, Betrag : 0,0957, DealAmount: 0,0957, Durchschnittlicher Preis: 8444,69999999, Typ: 1, Offset: 0, Status : 1, ContractType: bBTC_USDT_OKX}

In [15]:

nowQuarterAcc = exchanges[0].GetAccount()   # Get the current futures exchange account information, recorded in the variable nowQuarterAcc.
nowQuarterAcc

Ausgeschaltet[15]: {Bilanz: 0,0, FrozenBalance: 0,0, Lagerbestände: 1,021786026184, FrozenStocks: 0,0}

In [16]:

nowSpotAcc = exchanges[1].GetAccount()      # Get the current spot exchange account information, recorded in the variable nowSpotAcc.
nowSpotAcc

Ausgeschaltet [1]: (Bilanz: 9834,74705446, FrozenBalance: 0,0, Bestände: 0,0, FrozenStocks: 0,0}

Durch den Vergleich der Ausgangssumme mit der Leistungsbilanz wird der Gewinn und Verlust der Sicherungsgeschäfte berechnet.

In [17]:

diffStocks = abs(nowQuarterAcc.Stocks - initQuarterAcc.Stocks)
diffBalance = nowSpotAcc.Balance - initSpotAcc.Balance
if nowQuarterAcc.Stocks - initQuarterAcc.Stocks > 0 :
    print("profits:", diffStocks * spotTicker2.Buy + diffBalance)
else :
    print("profits:", diffBalance - diffStocks * spotTicker2.Buy)

Ausgeschaltet [1]: Gewinn: 18,72350977580652

Jetzt sehen wir, warum die Absicherung profitabel ist. Wir können das Diagramm sehen. Der Futures-Preis ist eine blaue Linie und der Spot-Preis ist eine orange Linie. Beide Preise sinken. Der Futures-Preis sinkt schneller als der Spot-Preis.

In [18]:

xQuarter = [1, 2]
yQuarter = [quarterTicker1.Buy, quarterTicker2.Sell]

xSpot = [1, 2]
ySpot = [spotTicker1.Sell, spotTicker2.Buy]
plt.plot(xQuarter, yQuarter, linewidth=5)
plt.plot(xSpot, ySpot, linewidth=5)
plt.show()

Ausgeschaltet[1]:

Der Kursunterschied liegt zwischen 284 zum Zeitpunkt der Absicherung der Eröffnungsposition (d. h. Futures gehen kurz und Spot gehen lang) und 52 zum Zeitpunkt des Schließens der Position (Futures schließen kurz, Spot schließen lang).

In [19]:

xDiff = [1, 2]
yDiff = [quarterTicker1.Buy - spotTicker1.Sell, quarterTicker2.Sell - spotTicker2.Buy]
plt.plot(xDiff, yDiff, linewidth=5)
plt.show()

Ausgeschaltet[1]:

Zum Beispiel ist a1 der Futures-Preis zum Zeitpunkt 1 und b1 der Spot-Preis zum Zeitpunkt 1. A2 ist der Futures-Preis zum Zeitpunkt 2 und b2 ist der Spot-Preis zum Zeitpunkt 2.Solange die Futures-Spotpreisdifferenz zum Zeitpunkt 1 (a1-b1) größer ist als die Futures-Spotpreisdifferenz zum Zeitpunkt 2 (a2-b2), kann a1 - a2>b1 - b2 eingeführt werden. Es gibt drei Situationen: (die Menge der Futures und der Spotpositionen ist gleich)

a1 - a2 ist größer als 0, b1 - b2 ist größer als 0 a1 - a2 bezieht sich auf die Preisunterschiede der Futures-Gewinne und b1 - b2 bezieht sich auf die Preisunterschiede der Spot-Verluste (weil der Spot lang ging, ist der Preis des Kaufbeginns höher als der Preis des Verkaufs, um die Position zu schließen, so dass das Geld verloren geht), aber die Futures-Gewinne sind größer als die Spot-Verluste.
a1 - a2 ist größer als 0, b1 - b2 ist kleiner als 0 a1 - a2 ist die Preisunterschiede der Futures-Gewinne und b1 - b2 ist die Preisunterschiede der Spot-Gewinne (b1 - b2 ist kleiner als 0, was bedeutet, dass b2 größer ist als b1, d. h. der Preis der Eröffnungs- und Kaufposition niedrig ist und der Preis des Verkaufs und Schließens hoch ist, so dass er profitabel ist).
a1 - a2 weniger als 0, b1 - b2 weniger als 0 a1 - a2 ist die Preisdifferenz der Futures-Verluste und b1 - b2 ist die Preisdifferenz der Spotgewinne. Da a1 - a2 > b1 - b2 ist der absolute Wert von a1 - a2 kleiner als der absolute Wert von b1 - b2 und die Spotgewinne größer als die Futures-Verluste. Es ist insgesamt profitabel.

Es gibt keinen Fall, in dem a1 - a2 kleiner als 0 und b1 - b2 größer als 0 ist, weil a1 - a2 > b1 - b2 definiert wurde. Ähnlich, wenn a1 - a2 gleich 0 ist, da a1 - a2 > b1 - b2 definiert ist, muss b1 - b2 kleiner als 0 sein. Daher, solange die Absicherungsmethode von Short Futures und Long Spot die Bedingungen a1 - b1 > a2 - b2 erfüllt, sind die Eröffnungs- und Schließpositionstransaktionen Gewinnabsicherung.

Das folgende Modell ist beispielsweise einer der Fälle:

In [20]:

a1 = 10
b1 = 5
a2 = 11
b2 = 9

# a1 - b1 > a2 - b2 launches: a1 - a2 > b1 - b2

xA = [1, 2]
yA = [a1, a2]

xB = [1, 2]
yB = [b1, b2]
plt.plot(xA, yA, linewidth=5)
plt.plot(xB, yB, linewidth=5)
plt.show()

Ausgeschaltet[1]:

Suchumgebung JavaScript Sprachdatei

Die Forschungsumgebung unterstützt nicht nur Python, sondern auch JavaScript Ich gebe auch ein Beispiel für eine JavaScript-Forschungsumgebung:

Analyse des Grundsatzes der Futures-Spot-Hedging (JavaScript).ipynb In [1]:

// Import the required package, click "Save settings" on the FMZ's "Strategy editing page" to get the string configuration and convert it to an object.
var fmz = require("fmz")                           // Import the talib, TA, and plot libraries automatically after import
var task = fmz.VCtx({
start: '2019-09-19 00:00:00',
end: '2019-09-28 12:00:00',
period: '15m',
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD","stocks":1},{"eid":"OKX","currency":"BTC_USDT","balance":10000,"stocks":0}]
})

In [2]:

exchanges[0].SetContractType("quarter")  // The first exchange object OKX Futures (eid: Futures_OKCoin) calls the function to set the current contract as a quarterly contract.
var initQuarterAcc = exchanges[0].GetAccount()  // The initial account information of OKX Futures Exchange is recorded in the variable initQuarterAcc.
initQuarterAcc

Ausgeschaltet[2]: { Saldo: 0, FrozenBalance: 0, Lagerbestände: 1, FrozenStocks: 0 }

In [3]:

var initSpotAcc = exchanges[1].GetAccount()     // The initial account information of the OKX Spot Exchange is recorded in the variable initSpotAcc.
initSpotAcc

Ausgeschaltet[3]: { Saldo: 10 000, FrozenBalance: 0, Lagerbestände: 0, FrozenStocks: 0 }

In [4]:

var quarterTicker1 = exchanges[0].GetTicker()   // Get the futures exchange ticker, recorded in the variable quarterTicker1.
quarterTicker1

Ausgeschaltet[4]: (Zeit: 1568851210000) Hoch: 10441.25002, Niedrig: 10441,25. Verkaufen: 10441.25002, Kaufen: 10441.25, Zuletzt: 10441.25001, Band: 1772. Offener Interesse: 0 }

In [5]:

var spotTicker1 = exchanges[1].GetTicker()     // Get the spot exchange ticker, recorded in the variable spotTicker1.
spotTicker1

Ausgeschaltet[5]: (Zeit: 1568851210000) Hoch: 10156.60000002, Niedrig: 10156,6. Verkaufen: 10156.60000002, Kaufen: 10156,6, Zuletzt: 10156.60000001, Volumen: 7.4443, Offener Interesse: 0 }

In [6]:

quarterTicker1.Buy - spotTicker1.Sell         // The price difference between going short on futures and going long on spot.

Ausgeschaltet[6]: 284,6499999799999985 In [7]:

exchanges[0].SetDirection("sell")             // Set up a futures exchange and trade in the direction of going short
var quarterId1 = exchanges[0].Sell(quarterTicker1.Buy, 10)  // Go short futures to place orders. The order quantity is 10 contracts. The returned order ID is recorded in the variable quarterId1.
exchanges[0].GetOrder(quarterId1)                           // Check the details of the order with futures order ID quarterId1.

Aus[7]: {Id: 1, Preis: 10441.25, Betrag: 10 DealAmount: 10, Durchschnittspreis: 10441,25. Typ: 1, Abstand: 0, Status: 1, Vertragsart: quarter }

In [8]:

var spotAmount = 10 * 100 / quarterTicker1.Buy                  // Calculate the currency equivalent of 10 contracts as the order quantity of the spot.
var spotId1 = exchanges[1].Buy(spotTicker1.Sell, spotAmount)    // Place orders on the spot exchange.
exchanges[1].GetOrder(spotId1)                                  // Check the order details of the spot order ID of spotId1.

Ausgeschaltet[8]: {Id: 1, Preis: 10156.60000002, Betrag: 0,0957, DealAmount: 0,0957, Durchschnittlicher Preis: 10156.60000002, Typ: 0, Versatz: 0, Status: 1, Vertragstyp: BTC_USDT_OKX }

Sie können sehen, dass die Aufträge quarterId1 und spotId1 vollständig ausgefüllt sind, d. h. die Absicherung der eröffneten Positionen abgeschlossen ist.

In [9]:

Sleep(1000 * 60 * 60 * 24 * 7)            // Hold the position for a while and wait for the price difference to become smaller to close the position.

In [10]:

var quarterTicker2 = exchanges[0].GetTicker()    // Get the current futures exchange ticker, recorded in the variable quarterTicker2.
quarterTicker2

Ausgeschaltet[10]: (Zeit: 1569456010000) Hoch: 8497.20002, Niedrig: 8497.2, Verkaufen: 8497.20002. Kaufen: 8497.2, Zuletzt: 8497.20001. Volumen: 4311 Offener Interesse: 0 }

In [11]:

var spotTicker2 = exchanges[1].GetTicker()       // Get the current ticker of the spot exchange, recorded in the variable spotTicker2.
spotTicker2

Ausgeschaltet[11]: (Zeit: 1569456114600) Hoch: 8444.70000001, Niedrig: 8444,69999999, Verkaufen: 8444.70000001, Kaufen: 8444.69999999, Zuletzt: 8444,7. Volumen: 78.6273 Offene Interessen: 0 }

In [12]:

quarterTicker2.Sell - spotTicker2.Buy            // The price difference between closing short position of futures and closing long position of spot.

Ausgeschaltet[12]: 52.5000200100003

In [13]:

exchanges[0].SetDirection("closesell")           // Set the current trading direction of the futures exchange to close short positions.
var quarterId2 = exchanges[0].Buy(quarterTicker2.Sell, 10)       // The futures exchange places an order to close the position, and records the order ID to the variable quarterId2.
exchanges[0].GetOrder(quarterId2)                                // Check futures closing position order details.

Aus dem Spiel[13]: (Id: 2), Preis: 8497.20002, Betrag: 10 DealAmount: 10, Durchschnittlicher Preis: 8493,95335, Typ: 0, Ausgleich: 1, Status: 1, Vertragsart: quarter }

In [14]:

var spotId2 = exchanges[1].Sell(spotTicker2.Buy, spotAmount)     // The spot exchange places an order to close the position, and records the order ID to the variable spotId2.
exchanges[1].GetOrder(spotId2)                                   // Check spot closing position order details.

Ausgeschaltet[1]: (Id: 2), Preis: 8444,69999999, Betrag: 0,0957, DealAmount: 0,0957, Durchschnittlicher Preis: 8444,69999999, Typ: 1, Abstand: 0, Status: 1, Vertragstyp: BTC_USDT_OKX }

In [15]:

var nowQuarterAcc = exchanges[0].GetAccount()     // Get the current futures exchange account information, recorded in the variable nowQuarterAcc.
nowQuarterAcc

Ausgeschaltet[1]: { Saldo: 0, FrozenBalance: 0, Lagerbestände: 1,021786026184, FrozenStocks: 0

In [16]:

var nowSpotAcc = exchanges[1].GetAccount()        // Get the current spot exchange account information, recorded in the variable nowSpotAcc.
nowSpotAcc

Ausgeschaltet [1]: { Saldo: 9834.74705446, FrozenBalance: 0, Bestände: 0, FrozenStocks: 0 Durch den Vergleich der Ausgangssumme mit der Leistungsbilanz wird der Gewinn und Verlust der Sicherungsgeschäfte berechnet.

In [17]:

var diffStocks = Math.abs(nowQuarterAcc.Stocks - initQuarterAcc.Stocks)
var diffBalance = nowSpotAcc.Balance - initSpotAcc.Balance
if (nowQuarterAcc.Stocks - initQuarterAcc.Stocks > 0) {
    console.log("profits:", diffStocks * spotTicker2.Buy + diffBalance)
} else {
    console.log("profits:", diffBalance - diffStocks * spotTicker2.Buy)
}

Ausgeschaltet [1]: Gewinn: 18,72350977580652

In [18]:

var objQuarter = {
    "index" : [1, 2],                                          // The index is 1, that is, the first time, the opening time, and 2 is the closing time.
    "arrPrice" : [quarterTicker1.Buy, quarterTicker2.Sell],
}
var objSpot = {
    "index" : [1, 2],
    "arrPrice" : [spotTicker1.Sell, spotTicker2.Buy],
}
plot([{name: 'quarter', x: objQuarter.index, y: objQuarter.arrPrice}, {name: 'spot', x: objSpot.index, y: objSpot.arrPrice}])

Ausgeschaltet[1]: Der Kursunterschied liegt zwischen 284 zum Zeitpunkt der Absicherung der Eröffnungspositionen (d. h. die Futures gingen kurz und der Spot lang) und 52 zum Zeitpunkt des Schließens (Schließung der Short-Position der Futures und Schließung der Long-Position des Spot).

In [19]:

var arrDiffPrice = [quarterTicker1.Buy - spotTicker1.Sell, quarterTicker2.Sell - spotTicker2.Buy]
plot(arrDiffPrice)

Ausgeschaltet[1]:Zum Beispiel ist a1 der Futures-Preis zum Zeitpunkt 1 und b1 der Spot-Preis zum Zeitpunkt 1. A2 ist der Futures-Preis zum Zeitpunkt 2 und b2 ist der Spot-Preis zum Zeitpunkt 2.Solange die Futures-Spotpreisdifferenz zum Zeitpunkt 1 (a1-b1) größer ist als die Futures-Spotpreisdifferenz zum Zeitpunkt 2 (a2-b2), kann a1 - a2>b1 - b2 eingeführt werden. Es gibt drei Situationen: (die Menge der Futures und der Spotpositionen ist gleich)

a1 - a2 ist größer als 0, b1 - b2 ist größer als 0 a1 - a2 bezieht sich auf die Preisunterschiede der Futures-Gewinne und b1 - b2 bezieht sich auf die Preisunterschiede der Spot-Verluste (weil der Spot lang ging, ist der Preis des Kaufbeginns höher als der Preis des Verkaufs, um die Position zu schließen, so dass das Geld verloren geht), aber die Futures-Gewinne sind größer als die Spot-Verluste.
a1 - a2 ist größer als 0, b1 - b2 ist kleiner als 0 a1 - a2 ist die Preisunterschiede der Futures-Gewinne und b1 - b2 ist die Preisunterschiede der Spot-Gewinne (b1 - b2 ist kleiner als 0, was bedeutet, dass b2 größer ist als b1, d. h. der Preis der Eröffnungs- und Kaufposition niedrig ist und der Preis des Verkaufs und Schließens hoch ist, so dass er profitabel ist).
a1 - a2 weniger als 0, b1 - b2 weniger als 0 a1 - a2 ist die Preisdifferenz der Futures-Verluste und b1 - b2 ist die Preisdifferenz der Spotgewinne. Da a1 - a2 > b1 - b2 ist der absolute Wert von a1 - a2 kleiner als der absolute Wert von b1 - b2 und die Spotgewinne größer als die Futures-Verluste. Es ist insgesamt profitabel.

Das folgende Modell ist beispielsweise einer der Fälle:

In [20]:

var a1 = 10
var b1 = 5
var a2 = 11
var b2 = 9

// a1 - b1 > a2 - b2 launches: a1 - a2 > b1 - b2

var objA = {
    "index" : [1, 2],
    "arrPrice" : [a1, a2],
}
var objB = {
    "index" : [1, 2],
    "arrPrice" : [b1, b2],
}
plot([{name : "a", x : objA.index, y : objA.arrPrice}, {name : "b", x : objB.index, y : objB.arrPrice}])

Ausgeschaltet[1]:

Probiert es aus, Leute!

Verwandt

Mehr