R : i primi 30 minuti (dall’installazione al primo Trading-System) (1 Viewer)

cammello

Forumer storico
- Cerchi di modificarlo con R aperto, per caso?
- Ma quello dovrebbe essere sul tuo PC, infatti per me il manuale di lm sta ad esempio all'indirizzo http://127.0.0.1:28955/library/stats/html/lm.html.

Forse ci sono problemi con l'installazione di R :mmmm:

a) teoricamente è chiuso (consolle, RExcel)
b) mi sa di si; pennico e poi dis/re-installo, vediamo che succede

merci

C
 
woow O.O...grande cren!!!... è proprio vero che la notte porta consiglio! :p ma il procedimento vale anche se prendessi in considerazione solo 5 opzioni dal momento che non posso andare fuori traccia!!! e poi, esiste una risoluzione più "adatta" a noi "poveri mortali" :p??
 
Ultima modifica:

Cren

Forumer storico
jack12 ha scritto:
ciao cren,
ho provato a risolvere la mia tesina attenendomi di più alla traccia originale, cioè le "famose" 5 opzioni da costruire (per poi calcolare i volatility smile). Ho prevalentemente utilizzato il pacchetto RquantLib di R partendo dalla funzione "europeanOptionsImpliedVolatility". mi chiedevo se fossi così paziente da dare uno sguardo a quanto da me svolto e da suggerirmi le opportune correzioni (soprattutto per quanto riguarda i risultati). Grazie in anticipo:

1) ho costruito arbitrariamente 5 call aventi:
A) value=11.10, underlying=100, strike=100;
B)11.30, 110, 110;
C)11.50, 120, 120;
D)12.05, 130, 130;
E)12.20, 140, 140;
ed ho fissato: dividendYield=0.01 riskFreeRate=0.03 volatility=0.4 e maturity=0.5


svolgimento:

> VolatilitàImplicitaA=EuropeanOptionImpliedVolatility("call", value=11.10, strike=100, volatility=0.4, 100, 0.01, 0.03, 0.5)
> VolatilitàImplicitaA
$impliedVol
[1] 0.3805953

$parameters
$parameters$type
[1] "call"

$parameters$value
[1] 11.1

$parameters$underlying
[1] 100

$parameters$strike
[1] 100

$parameters$dividendYield
[1] 0.01

$parameters$riskFreeRate
[1] 0.03

$parameters$maturity
[1] 0.5

$parameters$volatility
[1] 0.4


attr(,"class")
[1] "EuropeanOptionImpliedVolatility" "ImpliedVolatility"
>

> VolatilitàImplicitaB=EuropeanOptionImpliedVolatility("call", value=11.30, strike=110, volatility=0.4, 110, 0.01, 0.03, 0.5)
> VolatilitàImplicitaB
$impliedVol
[1] 0.3507034

$parameters
$parameters$type
[1] "call"

$parameters$value
[1] 11.3

$parameters$underlying
[1] 110

$parameters$strike
[1] 110

$parameters$dividendYield
[1] 0.01

$parameters$riskFreeRate
[1] 0.03

$parameters$maturity
[1] 0.5

$parameters$volatility
[1] 0.4


attr(,"class")
[1] "EuropeanOptionImpliedVolatility" "ImpliedVolatility"
>
> VolatilitàImplicitaC=EuropeanOptionImpliedVolatility("call", value=11.50, strike=120, volatility=0.4, 120, 0.01, 0.03, 0.5)
> VolatilitàImplicitaC
$impliedVol
[1] 0.3258203

$parameters
$parameters$type
[1] "call"

$parameters$value
[1] 11.5

$parameters$underlying
[1] 120

$parameters$strike
[1] 120

$parameters$dividendYield
[1] 0.01

$parameters$riskFreeRate
[1] 0.03

$parameters$maturity
[1] 0.5

$parameters$volatility
[1] 0.4


attr(,"class")
[1] "EuropeanOptionImpliedVolatility" "ImpliedVolatility"
>
> VolatilitàImplicitaD=EuropeanOptionImpliedVolatility("call", value=12.05, strike=130, volatility=0.4, 130, 0.01, 0.03, 0.5)
> VolatilitàImplicitaD
$impliedVol
[1] 0.3144904

$parameters
$parameters$type
[1] "call"

$parameters$value
[1] 12.05

$parameters$underlying
[1] 130

$parameters$strike
[1] 130

$parameters$dividendYield
[1] 0.01

$parameters$riskFreeRate
[1] 0.03

$parameters$maturity
[1] 0.5

$parameters$volatility
[1] 0.4


attr(,"class")
[1] "EuropeanOptionImpliedVolatility" "ImpliedVolatility"
>
> VolatilitàImplicitaE=EuropeanOptionImpliedVolatility("call", value=12.20, strike=140, volatility=0.4, 140, 0.01, 0.03, 0.5)
> VolatilitàImplicitaE
$impliedVol
[1] 0.2944833

$parameters
$parameters$type
[1] "call"

$parameters$value
[1] 12.2

$parameters$underlying
[1] 140

$parameters$strike
[1] 140

$parameters$dividendYield
[1] 0.01

$parameters$riskFreeRate
[1] 0.03

$parameters$maturity
[1] 0.5

$parameters$volatility
[1] 0.4


attr(,"class")
[1] "EuropeanOptionImpliedVolatility" "ImpliedVolatility"
>
> StrikePrices=c(100, 110, 120, 130, 140)
> StrikePrices
[1] 100 110 120 130 140
> optionValues=c(11.10, 11.30, 11.5, 12.05, 12.20)
> optionValues
[1] 11.10 11.30 11.50 12.05 12.20
> volSmile<- rep(0,length(StrikePrices))
> volSmile
[1] 0 0 0 0 0
plot(x = StrikePrices, y = volSmile)
Il tuo codice ha dei problemi, nel senso che c'è un primo problema concettuale legato al fatto che per prima cosa hai specificato diversi valori del sottostante... ma in ogni istante il valore del sottostante è unico, non puoi estrarre le volatilità implicite così.

Dopodiché c'è un problema col codice nel senso che tu popoli un vettore di zeri e pretendi di stampare lo smile di volatilità... un po' pretenzioso ;)

Per avere lo smile di volatilità devi estrarre dagli oggetti di classe EuropeanOptionImpliedVolatility il valore che ti serve con l'operatore $impliedVol, quindi come asse delle ascisse va bene StrikePrices, ma come ordinate ti servono quei valori.
 
Ultima modifica:

thetruth34

Nuovo forumer
Ho cercato di fare il più possibile da solo, ma sono arrivato ad un punto morto con il codice e questione seguente.

Premessa: non sto ponendo alcuna attenzione sulla fattibilità della strategia (se fate caso i dati sono anche di scarsa qualità), nè accortezze da prendere in caso di una sua implementazione pratica. Il tutto è finto, ma mi serve solo per prendere mano con R.

L'idea è di testare una strategia banale (in questo caso con le Bollinger Bands) ed ottenere determinati output per valutarne la bontà. Output che purtroppo non c'erano su PerformanceAnalytics (pensato più per dati non intraday?) e comunque volevo valutare in ticks/dollari piuttosto che rendimenti. I dati non sono nulla di segreto, quindi eventualmente li allego in formato .csv.

La strategia prevede semplicemente long quando si è sotto la deviazione standard inferiore, short quando si è sopra la deviazione standard superiore e flat ogni qualvolta si tocca la media mobile e si rimane entro le deviazioni standard.

Ci sono alcune funzioni (mlag, iif, compute.drawdown.ticks) che son prese da qui: Systematic Investor Toolbox. In ogni caso mlag è molto simile al lag di R, iif è sostanzialmente l'if di Excel (i.e. condition, iftrue, iffalse) e compute.drawdown mi sembra chiaro :D (l'ho modificato io in compute.drawdown.ticks per farlo in valore assoluto in ticks, piuttosto che percentuale).

compute.drawdown.ticks <- function(x)
{
return(x - cummax(c(1,x))[-1] )
}
Questo quanto fatto finora (strategia prese da una domanda si StackExchange per la cronaca, a cui peraltro appartengono i primi commenti). Il resto son commenti miei in inglese stentato, ma penso si capisca tutto.

#*****************************************************************
# Load historical data, SIT and R packages
#*****************************************************************

setInternet2(TRUE)
con = gzcon(url('http://www.systematicportfolio.com/sit.gz', 'rb'))
source(con)
close(con)

load.packages('quantmod')
load.packages('data.table')
load.packages('xts')
load.packages('plyr')
load.packages('PerformanceAnalytics')
load.packages('zoo')
load.packages('gplots')
load.packages('lattice')

product <- read.zoo("C:/Users/utente/Desktop/DataForRAnalysis.csv", sep = ";", header= TRUE, index = 1:2, tz = "", format = "%d/%m/%Y %H:%M:%S")
product.xts <- as.xts(product)
colnames(product.xts)="Close"
head(product.xts)
Non fate caso ai pacchetti caricati (non tutti servono, ma son quelli che uso di solito), quello che abbiamo adesso in R è un xts fatto così (che altro non è che il file .csv allegato):

Img1

A questo punto costruisco la strategia:
#*****************************************************************
# Build strategy (Bollinger Bands)
#*****************************************************************

nLookback <- 700
nDeviation <- 2
dollars.per.ticks <- 10

strategy <-na.omit(merge(product.xts$Close,BBands(product.xts$Close, n = nLookback, sd = nDeviation)))
strategy <-strategy[,1:4]

strategy$sig <- NA

strategy$sig[c(FALSE, diff(sign(Cl(strategy) - strategy$mavg), na.pad=FALSE) != 0)] <- 0
strategy$sig[Cl(strategy) > strategy$up] <- -1 # short when Close is above up
strategy$sig[Cl(strategy) < strategy$dn] <- 1 # long when Close is below dn
strategy$sig[1] <- 0 # flat on the first day
strategy$sig[nrow(strategy)] <- 0 # flat on the last day

strategy$sig <- na.locf(strategy$sig) # wherever sig is NA, copy previous value to next row

strategy$sig <- Lag(strategy$sig) # Now Lag your signal to reflect that you can't trade on the same bar that your signal fires
strategy$sig[1] <- 0 # replace NA with zero position on first row
Ovvero stabilisco lunghezza della finestra mobile, deviazione standard su cui comprare/vendere e poi creo un dataframe xts in cui ho il Close dell'ultima candela, le bollinger bands e il segnale (long/short/flat):

Img2

Il segnale è stato laggato per non entrare sulla stessa barra, ma ripeto, non è questo quello che mi interessa ora. Il segnale comunque sembra funzionare:

Img3

Il Close della barra delle 11.05.00 è sopra la deviazione standard superiore ("up") e alle 11.06.00 la strategia si gira short.

A questo punto inizio a valutare la performance:
#*****************************************************************
# Performance Output
#*****************************************************************

sum(abs(diff(strategy$sig, na.pad=FALSE))) # Number of trades

sum(diff(Cl(strategy)) * strategy$sig, na.rm=TRUE)*100 # PnL of 1 share in ticks

plot(cumsum(diff(Cl(strategy), na.pad=FALSE) * strategy$sig[-1])*100*dollars.per.ticks) # Equity over time in dollars
La prima linea di codice mi dice semplicemente il numero di trades (trasforma la colonna sig, qualcosa come 0 -1 -1 -1 0 in 1 0 0 1 e poi ne fa la somma), la seconda la P&L in ticks e poi l'equity in dollari (dollars.per.ticks l'ho definito sopra). Questi i risultati:

Img4
Img5

Fin qui è dove ho potuto lurkare liberamente sul web e per quanto si accettino consigli per rendere il tutto più flessibile/bello/efficiente/realistico, sono abbastanza soddisfatto di quanto ottenuto. Da qui in poi ho dovuto fare io la maggior parte delle cose ( :D ) e quindi si accettano consigli su come migliorare il codice stesso. Da qui in poi l'obiettivo è calcolare una serie di statistiche relative ai risultati della strategia.

#*****************************************************************
# Trading Statistics
#*****************************************************************

eq.line.ticks=cumsum(diff(Cl(strategy), na.pad=FALSE) * strategy$sig[-1])*100 #Equity over time in ticks

eq.line.sig <- merge(eq.line.ticks,strategy$sig[2:nrow(strategy$sig)]) #New .xts dataframe with Equity over time and Signal (i.e. -1 = Short, 0 = Flat, +1 = Long)

sig = strategy$sig #new variable sig from strategy$sig (i.e. -1 = Short, 0 = Flat, +1 = Long)
sig1 = mlag(strategy$sig, -1) #lag of the new variable sig

tend = iif(sig != 0 & sig != sig1,1,0) # binary variable that shows when a trade ends (i.e. if long/short turns flat -> 1, otherwise 0)

last<-nrow(eq.line.ticks)

#eq.line.sig <- merge(eq.line.ticks,strategy$sig[2:last])
temp.trades <- merge(eq.line.ticks,strategy$sig[2:last], tend[2:last]) #xts dataframe with cumulative equity line in ticks, signal of trades and tend variable
temp.trades <- temp.trades[which(temp.trades$sig.1 > 0)] #xts dataframe with cum. equity line,signal and tend variable = 1
trades <- diff(temp.trades$Close)
trades[1]<-temp.trades$Close[1]
trades.summary<-merge(trades,temp.trades)
colnames(trades.summary) <- c("TradeResult","CumulativeEquityLine","Type","TradeEnd") #xts dataframe with single trade result, cum. equity line,signal and tend variable = 1
head(trades.summary)
Nella prima parte creo un nuovo dataframe sempre xts in cui ho la chiusura di tutte le trade (long e short), il risultato della singola trade in ticks, l'equity line cumulativa e un'ultima colonna "TradeEnd" che è semplicemente una variabile binaria che vale 1 quando una trade (long o short) finisce e 0 altrimenti.

Questo il risultato:

Img6

Da questo dataframe xts mi è molto più facile calcolare tutte le statistiche di mio interesse
avg.profit=mean(trades.summary$TradeResult)

avg.winning.trade=mean(trades.summary[trades.summary$TradeResult>0,"TradeResult"])

avg.losing.trade=mean(trades.summary[trades.summary$TradeResult<0,"TradeResult"])

number.of.trades=sum(abs(diff(strategy$sig, na.pad=FALSE))) # number of trades

number.of.roundtrips= sum(trades.summary[trades.summary$TradeResult<0,"TradeEnd"]) + sum(trades.summary[trades.summary$TradeResult>0,"TradeEnd"])

winning.trades = sum(trades.summary[trades.summary$TradeResult>0,"TradeEnd"])

losing.trades = sum(trades.summary[trades.summary$TradeResult<0,"TradeEnd"])

pct.winning = (winning.trades / (winning.trades + losing.trades)) * 100

dd=compute.drawdown.ticks(trades.summary$CumulativeEquityLine)
colnames(dd)="DD"
dd=dd[which(dd$DD<0)]
dd=as.matrix(dd)
max.dd=min(dd)
worst5.dd=sort(dd)[1:5]
avg.dd=mean(dd)
avg.worst5.dd=mean(sort(dd)[1:5])

Trading.Statistics=c(avg.profit,avg.winning.trade,avg.losing.trade,number.of.trades,number.of.roundtrips,winning.trades,losing.trades,pct.winning,max.dd,avg.dd,avg.worst5.dd)
Trading.Statistics.rows=c("avg.profit","avg.winning.trade","avg.losing.trade","number.of.trades","number.of.roundtrips","winning.trades","losing.trades","pct.winning","max.dd","avg.dd","avg.worst5.dd")
Trading.Statistics.df=data.frame(Trading.Statistics)
rownames(Trading.Statistics.df)=Trading.Statistics.rows
Trading.Statistics.df
E il risultato finale è il seguente:

Img7

Le "richieste di aiuto" sono:

1) Qualsiasi cosa che può valere la pena per migliorare la seconda parte in termini di flessibilità/linee di codice in meno/etcetc

2) Nonostante i miei fallimenti credo siano legati alla 1), mi interessebbe molto poter fare una analisi di sensitività al cui variare di nLookback (i.e. lunghezza finestra mobile per le Bollinger Bands) e nDeviation (i.e. quale deviazione standard utilizzare per comprare/vendere) abbia le diverse "Trading Statistics" dell'ultimo passaggio. Meglio ancora sarebbe per riga avere nLookback che varia, per colonna nDeviation che varia e in mezzo una volta le statistiche di interesse (avg.profit, avg.winning.trade blabla).

I miei tentativi con un ciclo di For son falliti miseramente, ma credo che quello che ho provato a dare in pasto ad R avrebbe fatto accapponare la pelle a qualsiasi programmatore della domenica :D (e sicuramente R si è rifiutato di farlo!).

Consigli/pareri?
 

Allegati

  • DataForRAnalysis.csv
    400,5 KB · Visite: 267
Ultima modifica:

cammello

Forumer storico
Ho cercato di fare il più possibile da solo, ma sono arrivato ad un punto morto con il codice e questione seguente.

Premessa: non sto ponendo alcuna attenzione sulla fattibilità della strategia (se fate caso i dati sono anche di scarsa qualità), nè accortezze da prendere in caso di una sua implementazione pratica. Il tutto è finto, ma mi serve solo per prendere mano con R.

L'idea è di testare una strategia banale (in questo caso con le Bollinger Bands) ed ottenere determinati output per valutarne la bontà. Output che purtroppo non c'erano su PerformanceAnalytics (pensato più per dati non intraday?) e comunque volevo valutare in ticks/dollari piuttosto che rendimenti. I dati non sono nulla di segreto, quindi eventualmente li allego in formato .csv.

La strategia prevede semplicemente long quando si è sotto la deviazione standard inferiore, short quando si è sopra la deviazione standard superiore e flat ogni qualvolta si tocca la media mobile e si rimane entro le deviazioni standard.

Ci sono alcune funzioni (mlag, iif, compute.drawdown.ticks) che son prese da qui: Systematic Investor Toolbox. In ogni caso mlag è molto simile al lag di R, iif è sostanzialmente l'if di Excel (i.e. condition, iftrue, iffalse) e compute.drawdown mi sembra chiaro :D (l'ho modificato io in compute.drawdown.ticks per farlo in valore assoluto in ticks, piuttosto che percentuale).

Questo quanto fatto finora (strategia prese da una domanda si StackExchange per la cronaca, a cui peraltro appartengono i primi commenti). Il resto son commenti miei in inglese stentato, ma penso si capisca tutto.

Non fate caso ai pacchetti caricati (non tutti servono, ma son quelli che uso di solito), quello che abbiamo adesso in R è un xts fatto così (che altro non è che il file .csv allegato):

Img1

A questo punto costruisco la strategia:
Ovvero stabilisco lunghezza della finestra mobile, deviazione standard su cui comprare/vendere e poi creo un dataframe xts in cui ho il Close dell'ultima candela, le bollinger bands e il segnale (long/short/flat):

Img2

Il segnale è stato laggato per non entrare sulla stessa barra, ma ripeto, non è questo quello che mi interessa ora. Il segnale comunque sembra funzionare:

Img3

Il Close della barra delle 11.05.00 è sopra la deviazione standard superiore ("up") e alle 11.06.00 la strategia si gira short.

A questo punto inizio a valutare la performance:
La prima linea di codice mi dice semplicemente il numero di trades (trasforma la colonna sig, qualcosa come 0 -1 -1 -1 0 in 1 0 0 1 e poi ne fa la somma), la seconda la P&L in ticks e poi l'equity in dollari (dollars.per.ticks l'ho definito sopra). Questi i risultati:

Img4
Img5

Fin qui è dove ho potuto lurkare liberamente sul web e per quanto si accettino consigli per rendere il tutto più flessibile/bello/efficiente/realistico, sono abbastanza soddisfatto di quanto ottenuto. Da qui in poi ho dovuto fare io la maggior parte delle cose ( :D ) e quindi si accettano consigli su come migliorare il codice stesso. Da qui in poi l'obiettivo è calcolare una serie di statistiche relative ai risultati della strategia.

Nella prima parte creo un nuovo dataframe sempre xts in cui ho la chiusura di tutte le trade (long e short), il risultato della singola trade in ticks, l'equity line cumulativa e un'ultima colonna "TradeEnd" che è semplicemente una variabile binaria che vale 1 quando una trade (long o short) finisce e 0 altrimenti.

Questo il risultato:

Img6

Da questo dataframe xts mi è molto più facile calcolare tutte le statistiche di mio interesse
E il risultato finale è il seguente:

Img7

Le "richieste di aiuto" sono:

1) Qualsiasi cosa che può valere la pena per migliorare la seconda parte in termini di flessibilità/linee di codice in meno/etcetc

2) Nonostante i miei fallimenti credo siano legati alla 1), mi interessebbe molto poter fare una analisi di sensitività al cui variare di nLookback (i.e. lunghezza finestra mobile per le Bollinger Bands) e nDeviation (i.e. quale deviazione standard utilizzare per comprare/vendere) abbia le diverse "Trading Statistics" dell'ultimo passaggio. Meglio ancora sarebbe per riga avere nLookback che varia, per colonna nDeviation che varia e in mezzo una volta le statistiche di interesse (avg.profit, avg.winning.trade blabla).

I miei tentativi con un ciclo di For son falliti miseramente, ma credo che quello che ho provato a dare in pasto ad R avrebbe fatto accapponare la pelle a qualsiasi programmatore della domenica :D (e sicuramente R si è rifiutato di farlo!).

Consigli/pareri?
per le bollinger mi pare esista la libreria TTR, magari ti da quello che cerchi
per il for io o visto che se devo mettere la { sulla stessa riga della condizione for stessa sennò mi da complicazioni
for (i in 1:100) {
qui metti le istruzioni
}
poi per potresti vedere se fanno al caso tuo le apply, sapply e lapply

C
 

thetruth34

Nuovo forumer
per le bollinger mi pare esista la libreria TTR, magari ti da quello che cerchi


C
Usata la funzione di TTR, credo la carichi automaticamente con quantmod :up:
per il for io o visto che se devo mettere la { sulla stessa riga della condizione for stessa sennò mi da complicazioni
for (i in 1:100) {
qui metti le istruzioni
}
poi per potresti vedere se fanno al caso tuo le apply, sapply e lapply
Grazie del consiglio, purtroppo credo di non poterci lavorare prima di sera, ma vi faro' sapere! :)
 

Cren

Forumer storico
Ciao Ric, visto che cerchi consigli vediamo di tirare fuori qualcosa :D

Ho dato un'occhiata al codice, soprattutto la prima parte: penso che il prossimo gradino che devi fare per migliorare quel codice (che non vuol dire necessariamente renderlo più veloce, eh!) sia approfondire l'uso delle function (antesignane delle classi nel paradigma della programmazione ad oggetti).

Questo dovrebbe darti la flessibilità che cerchi.

Facciamo un esempio:
strategy$sig <- NA

strategy$sig[c(FALSE, diff(sign(Cl(strategy) - strategy$mavg), na.pad=FALSE) != 0)] <- 0
strategy$sig[Cl(strategy) > strategy$up] <- -1 # short when Close is above up
strategy$sig[Cl(strategy) < strategy$dn] <- 1 # long when Close is below dn
strategy$sig[1] <- 0 # flat on the first day
strategy$sig[nrow(strategy)] <- 0 # flat on the last day

strategy$sig <- na.locf(strategy$sig) # wherever sig is NA, copy previous value to next row​
Quando mi fai questa cosa qua, oltre a usare la furbata di na.locf() che francamente non conoscevo, stai comunque ragionando su tutto il vettore trattandolo come un'osservazione "oggi" su cui vai a ricostruire il passato.

E' assolutamente legittimo, ma ti sfido a farlo con condizioni molto più sofisticate di quella (giorni della settimana, orari particolari, soprattutto un data set più ampio in gioco in termini di variabili esplicative che non siano solo quel paio di vettori delle Bollinger)!

Valuta allora la creazione di un'apposita funzione che, prendendo gli stessi input oggi, restituisca una indicazione per domani (e.g. "BUY", "SELL", "SHORT", "COVER"): dopodiché prova rollapplyr() per fare una vera simulazione sul passato, cioé applicando la tua funzione che genera posizioni in modo iterativo sul passato fino ad oggi... in questo modo simuli veramente il passato.

Lo stesso per il computo della posizione: una volta che hai un vettore di "BUY", "SELL", "SHORT", "COVER", puoi scrivere un'altra funzione che, partendo da quel vettore preso in input, generi la tua posizione in ogni istante.

Guarda questa funzione, ad esempio:
fn <- function(product.xts, nLookback, nDeviation)
{
require(quantmod)
print(index(last(product.xts))) # stampa la data correntemente in elaborazione per capire poi in rollapplyr() a che punto sei del back test
strategy <- na.omit(merge(product.xts$Close, BBands(product.xts$Close, n = nLookback, sd = nDeviation)))
strategy <-strategy[,1:4]
sig <- NA
if(last(Cl(strategy)) > last(strategy$up))
{
sig <- "SHORT"​
}
if(last(Cl(strategy)) < last(strategy$dn))
{
sig <- "BUY"​
}
return(sig)​
}​
Dopodiché potresti voler compilare la funzione per renderla più veloce:
require(compiler)
fnc <- cmpfun(fn)
Infine applicarla in finestra scorrevole al tuo data frame:
rollapplyr(data = product.xts, width = nLookback + 1, FUN = fnc, nDeviation = nDeviation, nLookback = nLookback, by.column = FALSE)
Avvertenza! Non ho provato nulla di questa roba, l'ho scritta di getto quindi sicuramente ti darà un errore da qualche parte... :D

Commentiamo la soluzione adottata: anche all'occhio meno attento è assolutamente evidente che, nel caso descritto, questo accrocchio è ridondante e molto più complesso rispetto a lavorare con tutto il vettore come hai fatto tu.

Tuttavia la comodità di avere una funzione che prende in input:
- un data set
- un paio di parametri​
e ti restituisce la posizione per l'ultimo giorno "visto" dall'algoritmo ti consente di cambiare più facilmente tutte le condizioni senza mettere mano al cuore del codice, ma solo modificando l'interno della function e poi lasciando tutto il lavoro a rollapplyr() (che di errori concettuali non ne commette essendo un iteratore stupido, a differenza di noi che con le condizioni logiche sui vettori possiamo incartarci più facilmente).

Quindi veniamo al piatto forte della tua richiesta: come faccio a fare un'analisi di sensitività? Esattamente allo stesso modo: ovvero racchiudi tutto il tuo codice in una function che prende in input i dati e quello che vuoi variare e che in output ti spara le tue misure di sensitività in un vettore colonna.

Dopodiché un ciclo for(), come ti ha suggerito cammello, sarà sufficiente per tutto.
 

thetruth34

Nuovo forumer
Ho letto eh, giornate un po' impegnate, appena posso mi ci rimetto e vi faccio sapere (i.e. torno a chiedere aiuto al prossimo step a cui son bloccato :D )!
 

Cren

Forumer storico
Ho letto eh, giornate un po' impegnate, appena posso mi ci rimetto e vi faccio sapere (i.e. torno a chiedere aiuto al prossimo step a cui son bloccato :D )!
Se vuoi precedermi, io ho appena scoperto l'esistenza della funzione Vectorized(), ma non riesco bene a capire a cosa serva :D

Non so nemmeno se ho capito che i risultati su campo sono pressapoco questi: tu dai in pasto a Vectorized() una funzione non primitiva (cioé una funzione di R che non sia scritta e compilata interamente in C) e questa diventa un missile come tempi di esecuzione.

Boh... :mmmm:

Per chi vuole cimentarsi:
Cito:
[...] Ultimately this will involve some for of loop, but as that loop is being performed in a low-level language such as C it can be highly efficient and tailored to the particular task. [...]
 
Ultima modifica:

Users who are viewing this thread

Alto