Inglese
Spagnolo
Portoghese
Francese
TedescoIl più grande MAE su operazioni multiple
Abbiamo un frammento "Il più grande MAE".
È molto utile vedere come si comporta una strategia con un singolo ordine.
Per esperienza, ho notato spesso che è più efficiente lavorare con un paniere di ordini invece che con un singolo ordine. Ad esempio, è più saggio distribuire 1 % di rischio su un paniere di ordini, anziché l'intero 1% su un singolo ordine.
Con un paniere o degli ordini, avete una maggiore flessibilità in quanto potete scegliere più posizioni di ingresso. Non è necessario individuare la singola posizione di ingresso.
Se si aprono più ordini contemporaneamente, è necessario calcolare il MAE totale di tutte le posizioni aperte.
Questo calcolo è necessario se si aprono tutte le posizioni nella stessa direzione. (nessuna posizione di copertura)
Propongo qui due frammenti:
Il primo: "Più grandeMAEallTrade", sta dando il più grande MAE per Un contratto. Ho fatto il calcolo per un contratto per ottenere risultati accurati anche se la strategia aumenta la dimensione del contratto durante il periodo di In Sample.
Da questi risultati si può avere una buona idea, ad esempio se si lavora con una dimensione di 0,1 contratti.
pacchetto SQ.Columns.Databanks;
importare com.strategyquant.lib.L;
importare com.strategyquant.lib.SQUtils;
importare com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;
importare java.util.List;
importare java.util.ArrayList;
importare java.util.*;
importare java.lang.*;
// Modalità in Francia da Emmanuel Evrard per la comunità StrategyQuantX :)
public class BiggestMAEallTrade extends DatabankColumn
{
public BiggestMAEallTrade()
{
super(L.tsq("Biggest Multiple MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);
setWidth(140);
setTooltip(L.tsq("Biggest Multiple MAE - è la peggiore escursione massima avversa di tutte le operazioni aperte contemporaneamente"));
}
//------------------------------------------------------------------------
@Override
public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
{
double worstMAE = -Double.MAX_VALUE;
Date date = new Date();
Date dateTemp = new Date();
double Total1 = 0;
double Size1 = 0;
for(int i = 0; i worstMAE)
{
worstMAE = (Total1/order.Size);
}
}
return -1*worstMAE;
}
}
Il secondo: "Percentuale di negoziazione più alta", sta dando il più grande MAE rispetto a ContoBilancioQuesto è interessante per vedere se una strategia non usa abbastanza o se ha bisogno di troppe risorse. Saldo del conto.
Se avete un 5% Perdita massima giornaliera, si può vedere se si è al di sopra o al di sotto di esso.
pacchetto SQ.Columns.Databanks;
importare com.strategyquant.lib.L;
importare com.strategyquant.lib.SQUtils;
importare com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;
importare java.util.List;
importare java.util.ArrayList;
importare java.util.*;
importare java.lang.*;
// Modalità in Francia da Emmanuel Evrard per la comunità StrategyQuantX :)
public class BiggestMAEallTradePct extends DatabankColumn
{
public BiggestMAEallTradePct()
{
super(L.tsq("Biggest Multiple MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
setWidth(70);
setTooltip(L.tsq("Maggior multiplo MAE % - è la peggiore escursione massima avversa di tutte le operazioni aperte contemporaneamente rispetto a AccountBalance"));
}
@Override
public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
{
double worstMAE = -Double.MAX_VALUE;
Date date = new Date();
Date dateTemp = new Date();
double Total1 = 0;
double Total2 = 0;
for(int i = 0; i worstMAE)
{
worstMAE = Total2;
}
}
return -1*worstMAE;
}
}
Se avete posizioni multiple in direzione opposta, rialzista e ribassista, in questo caso potrebbe essere interessante avere un calcolo diverso:
Ho preso la MAE più grande e sottrarre la MFE della direzione opposta per ottenere il MAE globale di questo MAE più grande.
Questo funziona solo se i trade opposti sono aperti durante la MAE più grande e non dopo. Tuttavia questo calcolo può essere utile.
Ho apportato queste modifiche agli snippet Il più grandeMaTuttoCambiamento e Maggior percentuale di commercio di tutti i tipi di cibo
pacchetto SQ.Columns.Databanks;
importare com.strategyquant.lib.L;
importare com.strategyquant.lib.SQUtils;
importare com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;
importare java.util.List;
importare java.util.ArrayList;
importare java.util.*;
importare java.lang.*;
// Modalità in Francia da Emmanuel Evrard per la comunità StrategyQuantX :)
public class BiggestMAEallHedgingTrade extends DatabankColumn
{
public BiggestMAEallHedgingTrade()
{
super(L.tsq("Biggest Multiple Hedging MAE"), DatabankColumn.Decimal2PL, ValueTypes.Minimize, 0, 0, 100);
setWidth(140);
setTooltip(L.tsq("Biggest Multiple Hedging MAE - è la peggiore escursione massima avversa di tutte le operazioni aperte contemporaneamente"));
}
//------------------------------------------------------------------------
@Override
public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
{
double worstMAE1= -Double.MAX_VALUE;
double worstMAE2 = -Double.MAX_VALUE;
double BesttMFE1= -Double.MAX_VALUE;
Date date = new Date();
Date dateTemp = new Date();
double Total1 = 0;
double Size1 = 0;
int direzione = 0;
for(int i = 0; i worstMAE1)
{
worstMAE1 = (Total1/order.Size);
}
}
}
Totale1 = 0;
for(int i = 0; i worstMAE2)
{
worstMAE2 = (Total1/order.Size);
}
}
}
se (worstMAE1 >= worstMAE2)
{
Totale1 = 0;
for(int i = 0; i BesttMFE1)
{
BesttMFE1 = (Totale1/Dimensione ordine);
}
}
}
return -1*(worstMAE1 - BesttMFE1);
}
else if (worstMAE2 > worstMAE1)
{
Totale1 = 0;
for(int i = 0; i BesttMFE1)
{
BesttMFE1 = (Totale1/Dimensione ordine);
}
}
}
return -1*(worstMAE2 - BesttMFE1);
}
return 0;
}
}
pacchetto SQ.Columns.Databanks;
importare com.strategyquant.lib.L;
importare com.strategyquant.lib.SQUtils;
importare com.strategyquant.lib.SettingsMap;
import com.strategyquant.tradinglib.*;
importare java.util.List;
importare java.util.ArrayList;
importare java.util.*;
importare java.lang.*;
// Modalità in Francia da Emmanuel Evrard per la comunità StrategyQuantX :)
public class BiggestMAEallHedgingTradePct extends DatabankColumn
{
public BiggestMAEallHedgingTradePct()
{
super(L.tsq("Biggest Multiple Hedging MAE %"), DatabankColumn.Decimal2Pct, ValueTypes.Minimize, 0, 0, 100);
setWidth(100);
setTooltip(L.tsq("Biggest Multiple Hedging MAE % - è la peggiore escursione massima avversa di tutte le operazioni aperte contemporaneamente rispetto a AccountBalance"));
}
@Override
public double compute(SQStats stats, StatsTypeCombination combination, OrdersList ordersList, SettingsMap settings, SQStats statsLong, SQStats statsShort) throws Exception
{
double worstMAE1= -Double.MAX_VALUE;
double worstMAE2 = -Double.MAX_VALUE;
double BesttMFE1= -Double.MAX_VALUE;
Date date = new Date();
Date dateTemp = new Date();
double Total1 = 0;
double Total2 = 0;
int direzione = 0;
for(int i = 0; i worstMAE1)
{
worstMAE1 = Total2;
}
}
}
Totale1 = 0;
for(int i = 0; i worstMAE2)
{
worstMAE2 = Total2;
}
}
}
se (worstMAE1 >= worstMAE2)
{
Totale1 = 0;
for(int i = 0; i BesttMFE1)
{
BesttMFE1 = Total2;
}
}
}
return -1*(worstMAE1 - BesttMFE1);
}
else if (worstMAE2 > worstMAE1)
{
Totale1 = 0;
for(int i = 0; i BesttMFE1)
{
BesttMFE1 = Total2;
}
}
}
return -1*(worstMAE2 - BesttMFE1);
}
return 0;
}
}
