Programmazione Prorealtime Prorealtime:formule, indicatori, oscillatori, tsi ...

Ciao Black Swan :).
Allora, ho provato a buttar giu' un esempio ma non sono sicuro se e' questo che volevi ...

Prendo un grafico, nell'esempio il dax indice, tf 1-minuto, 15809 barre. Voglio plottare la distribuzione delle frequenze dell'rsi.

Prima limitazione: plottero' la distrubuzione nelle ultime 101 barre del grafico, le frequenze quindi le calcolo "solo" per le prime 15708 barre. Probabilmente si puo' calcolare anche per le ultime usando proprio quel codice di traslazione di cui si parlava stamattina ma adesso non ho voglia di complicare le cose.

1264453712xetradaxpf.png


Nell'ultima finestra c'e' l'indicatore (chiamiamolo cosi')
return barindex
che mi conta le barre.

Per calcolare le frequenze avevo pensato ad un semplice for ... next e invece mi da errore di ciclo infinito, ormai sta diventando la mia bestia nera sto errore :)

Prendo allora una strada piu' lunga. Definisco un indicatore di supporto che chiamo rsi freq

Codice:
if round(RSI[14](close)) = n  then
    ind = ind+1
endif

return ind
Contiene la variabile intera n>=0

Fatto questo ecco il codice della distribuzione delle frequenze

Codice:
if barindex < numbarre - 100 then
    ind = undefined
else
    ind = CALL "rsi freq"[numbarre - barindex]
endif

return ind
Contiene la variabile numbarre, a cui bisogna assegnare il valore 15809, cioe' l'ultimo valore di barindex (per quello ce l'avevo plottato sul grafico).

Attenzione che ci mette un po' per fare i calcoli, sembra quasi piantarsi ma poi ce la fa.
Ora cancello il grafico del prezzo e del barindex ed ecco il risultato

1264454018finale.png


Sotto ho anche aggiunto un contatore che mi indica i valori da 0 a 100.

Codice:
if barindex < numbarre - 100 then
    ind = undefined
else
    ind = -numbarre + barindex +100
endif

return ind
solita variabile numbarre.
Cosi' se voglio sapere qual e' la frequenza di un certo valore, ci vado sopra col mirino ed e' fatta.

Fammi sapere se era questo che volevi, altrimenti ne riparliamo con calma.

Meurault, grazie, è la distribuzione che cercavo.
Ero arrivato a calcolare le frequenze, quello che mi interessava era arrivare a capire in che modo determinati valori sono distribuiti.

L'idea era quella di vedere quali sono le variazioni dei prezzi attorno al TypicalPrice.

Qualcosa di simile è già inclusa nell'idea dell'indicatore sviluppato da Welles Wilder (se ricordo bene) l'Average True Range.

Proverò più tardi ad inserire le formule e a vedere come funziona.


Molto gentile :up:


Ciao Grandeeee

felice di rileggerti......ti trovo invecchiato a giudacare dal tuo avatare :lol::lol:

Sei ripassato a vedere come si sviluppa il "tuo" 3d ;)

Visto, lungo la strada ho incontrato giovani e ferventi menti che si sono unite al nostro progetto secretissimo di conquista totale dei mercati con il piccolo attrezzo dell'isola di Java. :eek: ma siccome è un piano secreto ancora non cielo dico a loro


P.S. mentre io perdevo tempo a scrivere stupidate Meurs ha risolto il tuo probl...grande

Ciao SuperTeTTTTsuo :)
contento di leggerti. Ben presto saremo stramiliardari :lol::lol::lol:

Invecchio !!!!! non mi ricordo le cose, sono smemoratoooooo
 
Ultima modifica:
ho un problema curioso, non so se a qualcuno sia capitato qualcosa di simile.

Nel backtest ho un codice che legge una condizione, se vera legge una seconda condizione che se vera scatena una vendita e azzera un flag.
Poi ho una terza condizione, se vera legge la seconda condizione che e vera scatena un acquisto ed azzera il flag di cui prima.
Quindi un qualcosa del genere

cond1 = close > dclose(1)
if Cond1 then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if (Cond3 and flag <> 0) then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
if Cond2= -1 then
buy ecc
flag = 0
endif
endif
e poi tutti il resto

Ora se per farla più pulita sta cosa la scrivo come

Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
cond1 = close > dclose(1)
if Cond1 then
if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if Cond3 and flag <> 0 then
if Cond2 = -1 then
buy ecc
flag = 0
endif
endif

il risultato del backtest cambia, cosa che non dovrebbe essere.
Adesso mi direte che scrivo codice orripilante: eh si, però il punto non è questo, almeno penso :D

C
 
Complimenti

:eek::eek::eek:
Consideratemi arruolato :clava:

:lol::lol::lol:

Ciao Meursault,

Ti ringrazio infinitamente x la bravura nella programmazione di indicatori che metti a disposizione della comunità.

Credi sia possibile costruire in PRT l' indicatore denominato "pressione book" che sostituirebbe ore a gurdare il book?
Dovrebbe essere costruito sull'osservazione del primo livello di book:
-se il mercato colpisce il primo livello di ask significa che sta comprando;
- se il mercato colpisce il primo livello di bid significa che sta vendendo.
La costruzione dell'indicatore dovrebbe essere fatta rapportando, per ogni intervallo di tempo costante ( es. 150-300 secondi), l'ammontare dei volumi di ask sulla'ammontare dei volumi di totali registrati nell'intervallo di tempo considerato.

Attraverso l'individuazione di divergenze tra il movimento dei prezzi e l'indicatore pressione book è possibile individuare situazioni di marcato squilibrio, in cui è fortemente probabile un movimento di reazione in senso opposto.


Grazie GRANDE MEUR....Paki:)
 
ho un problema curioso, non so se a qualcuno sia capitato qualcosa di simile.

Nel backtest ho un codice che legge una condizione, se vera legge una seconda condizione che se vera scatena una vendita e azzera un flag.
Poi ho una terza condizione, se vera legge la seconda condizione che e vera scatena un acquisto ed azzera il flag di cui prima.
Quindi un qualcosa del genere

cond1 = close > dclose(1)
if Cond1 then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1) :wall::wall: if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if (Cond3 and flag <> 0) then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
if Cond2= -1 then
buy ecc
flag = 0
endif
endif
e poi tutti il resto

Ora se per farla più pulita sta cosa la scrivo come

Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
cond1 = close > dclose(1)
if Cond1 then
if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if Cond3 and flag <> 0 then
if Cond2 = -1 then
buy ecc
flag = 0
endif
endif

il risultato del backtest cambia, cosa che non dovrebbe essere.
Adesso mi direte che scrivo codice orripilante: eh si, però il punto non è questo, almeno penso :D

C

visual basic??
se si, mi sta succedendo la stessa cosa col zigzag (codice originale by tetsuo)

in pratica, VB non' considera chiuso' l'if dove ho messo lo smile :wall::wall:
e quindi non procede correttamente
inoltre, se metti la cond2 all'interno di un IF, potrebbe creare definizioni strane
IMHO, la versione corretta è la seconda

cmq, per questi casi, in VB io mi aiuto nel debuggin 'stampando' sul foglio excel il valore delle variabili ad ogni ciclo


ciao :)
 
visual basic??
se si, mi sta succedendo la stessa cosa col zigzag (codice originale by tetsuo)

in pratica, VB non' considera chiuso' l'if dove ho messo lo smile :wall::wall:
e quindi non procede correttamente
inoltre, se metti la cond2 all'interno di un IF, potrebbe creare definizioni strane
IMHO, la versione corretta è la seconda

cmq, per questi casi, in VB io mi aiuto nel debuggin 'stampando' sul foglio excel il valore delle variabili ad ogni ciclo


ciao :)

Hai ragione, manca il soggetto. ProRealtime.

C
 
Hai ragione, manca il soggetto. ProRealtime.

C

Ok .... però secondo me dice bene riguardo al "debugging".... in pratica quel che dovresti fare è portare entrambi i backtest in probuilder come fossero indicatori (al posto di buy e sell ci metti due variabili segnale, tipo long=1 e long=0) e nei return di ciascuno dei due aggiungere le flag e le condizioni così le plotti e puoi vedere dove scattano le diff e perché.
 
Ok .... però secondo me dice bene riguardo al "debugging".... in pratica quel che dovresti fare è portare entrambi i backtest in probuilder come fossero indicatori (al posto di buy e sell ci metti due variabili segnale, tipo long=1 e long=0) e nei return di ciascuno dei due aggiungere le flag e le condizioni così le plotti e puoi vedere dove scattano le diff e perché.

e lo sapevo che qui mi davae una buona idea :up:

Domani provo, che la cosa mi incuriosice troppo (oltre a mandarmi a banane una equity super extre mega mandingo :lol:)

Grazie

C
 
cond1 = close > dclose(1)
if Cond1 then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if (Cond3 and flag <> 0) then
Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
if Cond2= -1 then
buy ecc
flag = 0
endif
endif
e poi tutti il resto

Ora se per farla più pulita sta cosa la scrivo come

Cond2 = funzione( CCI[parametro], MA(CCI) ) (ritorna -1,0,1)
cond1 = close > dclose(1)
if Cond1 then
if Cond2= 1 then
sell ecc
flag = 0
endif
endif

cond3 = close < dclose(1)
if Cond3 and flag <> 0 then
if Cond2 = -1 then
buy ecc
flag = 0
endif
endif

il risultato del backtest cambia, cosa che non dovrebbe essere.

Ciao Cammello, la cosa ha incuriosito anche me ...
Sicuramente la strada indicata da Tetsuo e' quella migliore, volevo pero' fare un'osservazione (probabilmente inutile :D): nei 2 codici la differenza che salta agli occhi e' che, se close = dclose(1), nel primo codice la cond2 non viene definita (e PRT gli da quindi un valore di default? 0? 1? Non so), mentre nel secondo codice cond2 risulta sempre essere definita.

Se piu' avanti nei codici usi ancora degli if ... then sulla cond2 senza definirla ancora allora questo puo' darti risultati diversi a seconda se sia stata definita o meno in precedenza. Insomma, io comincerei a guardare i casi in cui close = dclose(1).

Spero che l'equity mandingo ti esca con il secondo codice :)

Ciao
 

Users who are viewing this thread

Back
Alto