I found amazing R package in one of posts on R-bloggers website. It's called RcppAmadillo and you can find more info here. The function I am using from this package is called fastLm. Whereas I am interested in special case of Ax = b problem where A and b are n x 1 vectors and x is only one-dimensional I ran the following test:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

require(rbenchmark)
require(RcppArmadillo)
 
x <- matrix(rnorm(1e6), ncol=1)
beta <- matrix(0.34, ncol=1)
y <- x %*% beta + rnorm(ncol(x), 0,5)
A <- data.frame(y, x)
 
benchmark(
lm.fit(x, y),
fastLm(x, y),
lm( y ~ x + 0),
lsfit(x, y), 
lm( y ~ . + 0, data=A),
columns=c("test", "replications", "elapsed", "relative"),
order="relative",
replications=10
)

And obtained this results:

test replications elapsed  relative
2            fastLm(x, y)           10   1.384  1.000000
1            lm.fit(x, y)           10   5.529  3.994942
4             lsfit(x, y)           10   5.900  4.263006
5 lm(y ~ . + 0, data = A)           10  20.842 15.059249
3           lm(y ~ x + 0)           10  23.637 17.078757

You can easily spot the difference and the reason why I am using fastLm from RcppAmadillo package. What I have added to this blog is new Page where you can find the example of 30 co-integrated pairs of companies from S&P 500 index. I am displaying plots from this post. If you have any recommendations what you would like to see or add to this page, feel free to contact me.

In order to update this page every day I was forced to automate the process of downloading data, finding co-integrated pairs, analyzing them and creating the corresponding plots. What I have used is Pyhon and the main script looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#!/usr/bin/python
 
#from subprocess import call
import subprocess
import time
 
start = time.time()
 
print "Running master R script"
subprocess.call(["R < /home/robo/Desktop/PairTrading/automat/master.R --no-save"], shell = True)
print "Running master R script - done!"
 
#, stdout = subprocess.PIPE)
 
print "Generating HTML.."
subprocess.call(["python htmlGenerator.py"], shell = True)
print "Done!"
 
end = time.time()
 
print "Elapsed time: " + str(end - start) + " s"
 
print "##################"
print "###  FINISHED  ###"
print "##################"
 
import testFTP.py

where I first run my R code, generate the HTML output in other Python file and finally upload the HTML output via FTP to the server. The main R code is as follows:

1
2
3
4
5
6
7
8
9
10
11

# Download data
 
source("/home/robo/Desktop/PairTrading/downloadV2.R")
 
# Find co-integrated pairs
 
source("/home/robo/Desktop/PairTrading/cointegrationV2.R")
 
# Analyze data and export output file
 
source("/home/robo/Desktop/PairTrading/analysisV2.R")

Simple! This way I can easily maintain and extend my code. Your comments are more than welcome.