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

[cammello]

Se vuoi precedermi, io ho appena scoperto l'esistenza della funzione Vectorized(), ma non riesco bene a capire a cosa serva

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...

Per chi vuole cimentarsi:

How to define a vectorized function in R
​

Cito:

visto già questo?
performance - Speed up the loop operation in R - Stack Overflow
(nei disegnini occhio alla scala di X)

C

 

[Cren]

visto già questo?
performance - Speed up the loop operation in R - Stack Overflow
(nei disegnini occhio alla scala di X)

Non l'avevo visto, impressionante.

Questa sembra sia la risposta per chi ha problemi di velocità computazionale con R:

The R Inferno​

 

[Cren]

Continua la sagra dei nostri simpatici amici dell'università prede di professoresse cattivissime che assegnano tesi senza dare aiuto

Oggi ci scrive rale1992, che per poter avere la tesi fatta & finita sopporterà di farsi spiattellare in pubblico qui di modo che il codice sia condivisibile da tutti:

Buona sera,
le chiedo scusa per il disturbo nel mandarle un messaggio privato, ma ho notato che lei è abbastanza esperto della piattaforma R e dei pacchetti ad essa connessi.
Se possibile vorrei chiederle un piccolo aiutino circa un comando, che non riesco a trovare ne su internet ne sui manuali, riguardante le strategie su opzioni.
La ringrazio anticipatamente.

Buona sera,
le chiedo scusa per il disturbo nel mandarle un messaggio privato, ma ho notato nei post precedenti che lei è abbastanza esperto della piattaforma R e dei pacchetti ad essa connessi.
Le scrivo per chiederle un piccolo aiutino su un comando che non riesco a trovare riguardante le strategie su opzioni.

La ringrazio anticipatamente.

Ciao, diamoci del tu.

Cos'è che vuoi fare?

Devo svolgere una tesina, ossia costruire cinque tipi di strategie operative su opzioni butterfly, utilizzando la piattaforma R e i pacchetti affini come performanceAnalytics, Quantlib, Quantmod.
Purtroppo ho difficoltà a trovare i comandi per le butterfly, potrebbe aiutarmi?

Grazie per la disponibilità.

Dovrei svolgere una tesina costruendo 5 tipi di strategie operative su opzioni butterfly, utilizzando la piattaforma R e i pacchetti affini come performanceAnalytics, Quantmod, Quantlib.
Purtroppo ho difficoltà nel trovare i comandi per le butterfly, potrebbe aiutarmi?

Grazie per la disponibilità.

In che senso "i comandi"?


Una butterfly è una semplice figura, la devi fare componendo più opzioni: poi le Greche si sommano mentre il P&L è una funzione definita a tratti (ma basta sommare le curve di P&L di ogni singola opzione).

Mi può far gentilmente un esempio pratico e grafico su una sola strategia per riuscir a capire meglio come impostarla?

Mi può far gentilmente un esempio pratico e grafico su una sola strategia per riuscir a capire meglio come impostarla?

L'esempio più semplice è questo: supponi un sottostante al prezzo S = 100.

Allora puoi comprare una Put strike 95 e una Call strike 105, e contemporaneamente vendere una Put e una Call strike 100.



Non riesco a capire bene che difficoltà hai, dal momento che basta inputare "butterfly spread" in Google per essere sommersi da tutti gli esempi pratici possibili.

Mi scuso, forse non mi sono espressa bene. Lo so che ci sono molti esempi pratici come quello che lei ora mi ha evidenziato, ma quello che intendevo dire io è se lei mi può mostrare un esempio applicativo in R con strategia operativa su opzioni butterfly, in quanto non ho grande conoscenza di tale piattaforma e nonostante le sue indicazioni ho difficoltà nel metterle in pratica in R, non vorrei sbagliare consegnando al prof. una tesina sbagliata.

La ringrazio.

Allego di seguito il codice con un po' di indicazioni per i frequentatori che hanno voglia di giocare un po' con R:

- scontato sottolineare i fini didattici visto che i prezzi sono inventati con Black & Scholes e non presi dal mercato (non avevo voglia di aprire l'Eurex, lo confesso );
- faccio notare l'uso della funzione Vectorize() a sua volta applicata ad una mia personale funzione scritta per l'occasione, e cioè terminalPayoff(), anche se da quanto ho capito in questo caso il motore in C non ne beneficia granché;
- faccio notare l'uso del costrutto switch(EXPR, alternatives) pressoché identico a quello che si usa in C++ e naturalmente la scelta migliore quando si hanno molte possibilità e non si vuole impazzire con gli ifelse() innestati (questo me lo chiedeva un altro utente poco tempo fa, così rispondo anche a lui...).​

Codice (come al solito fa tutto da solo):

# +---------------------------------
# | Sommario:
# |
# | 1. Installo le librerie
# | 2. Carico le librerie
# | 3. Definisco dei parametri arbitrari per prezzare le opzioni europee
# | 4. Prezzo le opzioni europee con Black & Scholes (volatilità costante)
# | 5. Definisco una funzione che rappresenti il payoff a scadenza una volta definita la posizione
# | 6. Calcolo i payoff a scadenza
# | 7. Rappresento graficamente i payoff in funzione del prezzo a scadenza del sottostante
# +---------------------------------

# +---------------------------------
# | 1. Installo le librerie
# +---------------------------------

install.packages('RQuantLib')

# +---------------------------------
# | 2. Carico le librerie
# +---------------------------------

require(compiler)
require(RQuantLib)

# +---------------------------------
# | 3. Definisco dei parametri arbitrari per prezzare le opzioni europee
# +---------------------------------

underlying <- 100
type <- c('put', 'put', 'call', 'call')
strike <- c(95, 100, 100, 105)
dividendYield <- 0
riskFreeRate <- 0
maturity <- 30/365
volatility <- .20

# +---------------------------------
# | 4. Prezzo le opzioni europee con Black & Scholes (volatilità costante)
# +---------------------------------

optionPrices <- NULL

for(i in 1:length(strike))
{

optionPrices <- EuropeanOption(type = type,

underlying = underlying,
strike = strike,
dividendYield = dividendYield,
riskFreeRate = riskFreeRate,
maturity = maturity,
volatility = volatility)$value​

​

}

# +---------------------------------
# | 5. Definisco una funzione che rappresenti il payoff a scadenza una volta definita la posizione
# +---------------------------------

# Possibili posizioni e rispettivo payoff:

# Long Call payoff = max[S(T) - K, 0] - c
# Short Call payoff = min[K - S(T), 0] + c
# Long Put payoff = max[K - S(T), 0] - p
# Short Put payoff = min[S(T) - K, 0] + p

terminalPayoff <- cmpfun(Vectorize(function(position, S_T, K, optionPrice)
{

payout <- switch(position,

'long call' = max(c(S_T - K, 0)) - optionPrice,
'short call' = min(c(K - S_T, 0)) + optionPrice,
'long put' = max(c(K - S_T, 0)) - optionPrice,
'short put' = min(c(S_T - K, 0)) + optionPrice)​

return(payout)​

}))

# +---------------------------------
# | 6. Calcolo i payoff a scadenza
# +---------------------------------

positionArray <- c('long put', 'short put', 'short call', 'long call')
x <- 90:110
y <- matrix(NA, nrow = length(x), ncol = 4)

for(i in 1:length(x))
{

for(j in 1:ncol(y))
{

y[i,j] <- terminalPayoff(positionArray[j], x, strike[j], optionPrices[j])​

}​

}

rownames(y) <- x
colnames(y) <- paste(positionArray, strike)

# +---------------------------------
# | 7. Rappresento graficamente i payoff in funzione del prezzo a scadenza del sottostante
# +---------------------------------

plot(y[,1] ~ x, lwd = 1, col = 2, type = 'l', xlab = 'Prezzo del sottostante', ylab = 'P&L a scadenza', ylim = c(min(y), max(y)), main = 'Short butterfly spread')
grid()

for(j in 2:ncol(y))
{

lines(y[,j] ~ x, lwd = 1, col = j + 1, type = 'l')​

}

lines(rowSums(y) ~ x, lwd = 3, type = 'l')
legend('bottomright', legend = paste(positionArray, strike), col = 2: (ncol(y) + 1), lwd = 1, bg = 'white')
abline(h = 0, lwd = 2, col = 'gray')​

Risultati in immagine.

Esco, ci leggiamo domani... tutti bocciati

 

[cammello]

Non ho capito se lo scambio sia limitato a ciò che hai messo qui o se nella costruzione ci sia stata anche una interazione più attiva.

Se ti trovi, consiglia al tuo pupillo un sussidiaro della grammatica italiana che mi pare che sia molto carente anche in questa.
E stiamo sempre parlando della futura classe dirigente italiana....

(ovvio che l'esempio me lo sono copia-incollato , grazie )

C

 

[Cren]

Non ho capito se lo scambio sia limitato a ciò che hai messo qui o se nella costruzione ci sia stata anche una interazione più attiva.

Tutto lì, dalla prima all'ultima riga

Per quanto riguarda la lingua, io cerco sempre di scrivere in un Italiano quantomeno leggibile (*) e - come te - apprezzo la forma corretta... tuttavia sono anche combattuto dalla "sindrome dell'efficientista" che non può far altro, pur soffrendone la grammatica e la bella forma, di valutare - che so - la morte del congiuntivo imperfetto o del (tra)passato remoto a favore in entrambi i casi dell'indicativo imperfetto un passo in avanti verso la semplificazione del linguaggio.

Ecco, poi "semplificazione" fa rima con "impoverimento", ma gli anglofoni vivono da sempre con un simple past per il passato di un periodo ipotetico o con un simple present per un'eventualità futura... e nonostante tutto penso siano abbastanza soddisfatti ceteris paribus delle loro giornate

Nel mondo del business quando c'è poco tempo vige la regola "basta capirsi", non importa come

(*) E sperabilmente corretto, non come GiuliaP che si permette di scrivere "qual'è" perché si considera sdoganata da Saviano

 

[Cren]

 

[Cren]

R is 15th of top programming languages in latest RedMonk ranking

Analyst firm RedMonk periodically publishes rankings of the Top 20 programming languages, as measured by activity on StackOverflow and number of repositories on GitHub. In their most recent ranking (January 2014), R is ranked #15 amongst all programming languages. An impressive ranking for a domain-specific language; the top 3 were the general-purpose languages Java, Javascript and PHP. Here's a chart of the raw rankings in both dimensions (and astute readers will notice from the ggplot2 chart that the ranking analysis itself was done in R):

Analyst Stephen O'Grady comments on the popularity of statistical languages in the latest rankings:

Both R and Matlab experienced gains this quarter, and this was the third consecutive quarter of growth for R in particular. While, as the plot indicates, these languages tend to outperform on Stack Overflow relative to GitHub, they are indicative of a continued rise in popularity for statistical analysis languages more broadly.

Also note the appearance of newcomer Julia on the chart, which has already attracted an impressive following in both GitHub and (to a lesser extent), StackOverflow.

O'Grady also noted that GitHub has sadly retired their rankings of top programming languages by number of repositories, but this analysis cleverly recreates the count of GitHib repositories using Google BigQuery and the GitHub Archive. Nonetheless, it does mean the methodology behind this analysis is slightly different than that of previous RedMonk programming language rankings.

RedMonk: The RedMonk Programming Language Rankings: January 2014
_________________________________

The change in rank from our last snapshot is in parentheses.

1. JavaScript (+1)
2. Java (-1)
3. PHP
4. C# (+2)
5. Python (-1)
6. C++ (+1)
7. Ruby (-2)
8. C
9. Objective-C
10. CSS (new)
11. Perl
12. Shell (-2)
13. Scala (-1)
14. Haskell
15. R (+1)
16. Matlab (+3)
17. Clojure (+5)
18. CoffeeScript (-1)
19. Visual Basic (+1)
20. Groovy (-2)
_________________________________

Osservazioni: mettere assieme linguaggi specialistici (come R e MATLAB) con roba generica ha senso?

Ma soprattutto: C# davanti a C++? E che cos'ha JavaScript di così speciale? E PHP? E quanto resiste il Visual Basic?

Tutte le risposte a Kazzenger

 

[Paolo1956]

Risposta alle osservazioni di Cren

a) non ha senso, non si mischian o le pere con le mele (anche se può aver senso richiamare DLL di terze parti all'interno di qualcosa

b) A tutti gli effetti Csharpe e VB sono la stessa cosa. C# è molto più semplice di C++ (usato seriamente, anche se ha il difetto che è proprietario); JS e PHP è roba per internet.

Ciao amico mio!

 

[Cren]

Risposta alle osservazioni di Cren

a) non ha senso, non si mischian o le pere con le mele (anche se può aver senso richiamare DLL di terze parti all'interno di qualcosa

b) A tutti gli effetti Csharpe e VB sono la stessa cosa. C# è molto più semplice di C++ (usato seriamente, anche se ha il difetto che è proprietario); JS e PHP è roba per internet.

Ciao amico mio!

Ciao, Paolo

Per curiosità, perché dici che C# e Visual Basic sono la stessa cosa?

Sulla maggior semplicità di C# rispetto a C++ non saprei dirti, sto ancora navigando con la mia barchetta di carta nell'oceano del secondo

 

[marofib]

Ciao, Paolo

Per curiosità, perché dici che C# e Visual Basic sono la stessa cosa?

Sulla maggior semplicità di C# rispetto a C++ non saprei dirti, sto ancora navigando con la mia barchetta di carta nell'oceano del secondo

tanto per darti un'idea


Convert C# to VB.NET - A free code conversion tool - developer Fusion