ecco il codice:
defParam cumulateOrders = false //(test DAX 15m)
once orderSize = 1
once raddoppio = 1
if StrategyProfit > StrategyProfit[1]and StrategyProfit[1] > StrategyProfit[2] then
IF Raddoppio = 1 THEN
orderSize = orderSize * 2
Raddoppio = 0
ELSE
orderSize = 1
ENDIF
elsif StrategyProfit < StrategyProfit[1] THEN
orderSize = 1
Raddoppio = 1
endif
//--------------
avg50 = average[50,0](close)
if close crosses over avg50 then
buy orderSize contract at market
endif
if longOnMarket and close < (avg50 - 50*pointSize) then
sell orderSize contract at market
endif
//-------------------------------------
set target pProfit 500
set stop pLoss 200
//--------------------------------------------
graph ordersize coloured(255,0,0,255)
graph Raddoppio coloured(0,0,255,255)
graph StrategyProfit < StrategyProfit[1] coloured(0,0,0,150)
Fino a venerdì mattina non riuscirò a modificarlo,
Grazie Roberto, fai con tutta calma non c’è nessuna fretta.
Per Phoentzs:
guardando il codice di Roberto per operazioni Martingala con il raddoppio della posizione soltanto una volta dopo la prima perdita, sono riuscito a riscrivere tale codice con la tua formula.
Ecco la sintesi (anche per altri utenti interessati) dei due codici: A ) raddoppio della posizione dopo la prima perdita e mantenimento del raddoppio fino ad una nuova operazione positiva – B) raddoppio della posizione soltanto una volta dopo la prima perdita
A)
defParam cumulateOrders = false
once positionSize = 1 //starting number of contracts
once minPositionSize = 1 //minimum lot size required by the broker
once maxPositionSize = 2
once increase = 1 //number of lots to increment
//once decrease = 1 //number of lots to decrement
if strategyProfit > strategyProfit[1] then
positionSize = positionSize – increase
elsIf strategyProfit < strategyProfit[1] then
positionSize = positionSize + increase
endif
positionSize = min(maxPositionSize, max(minPositionSize,positionSize)) //check both maximum and minimum
B)
defParam cumulateOrders = false
once positionSize = 1
once minPositionSize = 1
once maxPositionSize = 2
once increase = 1
// once decrease = 1
once flag = 1
if strategyProfit > strategyProfit[1] then
positionSize = positionSize - increase
flag = 1
elsIf strategyProfit < strategyProfit[1] then
if flag = 1 then
positionSize = positionSize + increase
flag = 0
else
positionSize = minPositionSize
endif
endif
positionSize = min(maxPositionSize, max(minPositionSize,positionSize))
Per Roberto:
sono riuscito a scrivermi il codice che ti avevo chiesto, grazie comunque per la disponibilità. Ti volevo invece chiedere una cosa didattica: come mai non si può utilizzare in questi codici per determinare un operazione negativa-positiva: positionPerf?
Strattegyprofit < strategyProfit[1] mi indica che il totale della strategia è minore rispetto al totale della strategia riferito all’operazione precedente, quindi c’è stata un operazione negativa-una perdita. Tuttavia per indicare che l’operazione precedente è stata negativa spesso, in altri codici scrivo e funziona,: if positionPerf(1) < 0 …
Come mai qui non va bene? (positionPerf era usato anche nella formula del manuale del resto)
Grazie Mauro, lo confronterò con la mia versione del codice nelle mie strategie quando ne avrò la possibilità.
Ho anche un codice simile da qualche parte in cui un MA è mappato sulla curva della strategia e la gestione del denaro funziona su di esso. Se siete interessati?
StrategyProfit restituisce il totale progressivo delle operazioni CHIUSE.
PositionPerf restituisce la percentuale di guadagno (o perdita, se è un valore negativo) dell’operazione aperta.
Quando un’operazione viene chiusa StrategyProfit viene aggiornata e PositionPerf azzerata. Quando si apre un’operazione, StrategyProfit resta invariara com’era prima e viene aggiornata PositionPerf candela per candela.
Sono due cose diverse, se t’interessa il totale basta che tu sommi le due ed avrai il totale acquisito + il totale corrente (temporaneo).
Per vedere se la tua strategia è storicamente profittevole o meno devi controllare StrategyProfit.
Per vedere, invece, se è l’operazione corrente è profittevole devi controllare PositionPerf.
StrategyProfit è espressa nella valuta del tuo conto.
PositionPerf può essere usata in questi modi:
- IF PositionPerf > 0 THEN per verificare che l’operazione aperta sia in profitto
- PerCent = PositionPerf * 100 per conoscere la percentuale in forma % (per default non è rapportata a 100)
- Pips = PositionPerf * PositionPrice / PipSize / PipValue per conoscere il profitto (o la perdita, se il dato è negativo) espresso in PIPS (ad esempio 42 pips)
- Pips = PositionPerf * PositionPrice / PipSize / / PipValue / abs(CountOfPosition) per conoscere il profitto (o la perdita, se il dato è negativo) espresso in PIPS, ma diviso per il numero di posizioni aperte (ad esempio 21 pips se sei in guadagno di 42 pips con 2 contratti)
- Money = PositionPerf * PositionPrice per conoscere il guadfagno (o la perdita) espressa in unità valutarie delle strumento su cui stai operando
Ciao Phoentzs se hai qualche codice che pensi sia valido postalo pure!
Ciao Roberto, ho integrato la tua risposta esaustiva alle varie annotazioni che mi ero fatto nel tempo di strategyProfit e positioPerf.
Non capisco però ancora una cosa: se al codice basta distinguere un operazione vincente da una perdente, questo non è fattibile in entrambi i modi:
strategyProfit > strategyProfit [1] mi dice che il totale progressivo dell’ultima operazione chiusa è maggiore rispetto al totale progressivo della penultima operazione chiusa: ossia che c’è stata un operazione positiva (che è quello che serve al codice)
Ma anche positionPerf(1) > 0 mi dice che l’ultima operazione è stata positiva [se invece uso positionPerf nel secondo modo, es: positionPerf(0) > 0.1 allora mi riferisco al guadagno specifico dell’ultima operazione ancora aperta]
Probabilmete c’è ancora qualcosa che mi sfugge.
positionPerf(1) ti restituisce la performance dell’operazione precedente.Forsse convertendola in moneta è uguale alla differenza di StrategyProfit, ma non l’ho verificato.
Secondo me è possibile in qualche modo: in un tuo vecchio appunto che mi ero segnato scrivevi:
“PositionPerf restituisce l’andamento di una posizione aperta, in percentuale sul prezzo. Generalmente si usa non tanto per sapere quant’è il guadagno (basta comunque fare la percentuale sul prezzo d’entrata per saperlo), quanto se è in profitto(>0) oppure in perdita(<0)”
In effetti questo usa va bene, ricordo un mio vecchio codice che avevo provato per variare lo stop in base ad un op vincente o perdente ed andava bene positionPerf, il codice era questo:
if positionPerf (1) <0 and positionPerf(2) <0 then
set stop % loss 2
else
set stop %loss 1
endif
Quando hai tempo prova a fare la conversione che dicevi è interessante. CIAO
