We use a very tricky example involving dates in R, explaining how to properly read dates coming in nonstandard formats. We review several strategies, the first one involving using as.Date(), and the second one using the ISODate() function that will create a POSIXct object. We discuss the difference between Dates and POSIXct objects, and we show how to use the days(), months() functions on the variables that we create

When we need to do very complex string pattern matching, or replacing we can't just rely on the traditional string functions. Regex expressions via the grep command allow us to search for patterns within strings in a very convenient way. We can also use this regex expressions on a replacement function, and do very complex string replacement operations.

Regex expressions are well known to most programmers, but it can be quite daunting to learn the basics. Here we show the essential operations that can be used as a basis for doing much more complex work

We review some extra concepts on Regex expressions, specially how to do quite complex replacements.

We combine the results from the previous Regex section with an appropriate R package that pulls and parses a web page. We use this approach to retrieve the Wikipedia article on Albert Einstein, and then build some statistical analysis on his impact on science. We end up identifying the key moments in his life, and his how his tremendous impact on science has evolved through time. All this, requiring no interaction with the user.

After developing our R production functions, we should always try to optimize them. The best way of doing that, is to profile the functions, and evaluate which other functions are called, and how much time each sub-call contributes to the overall time. 

Rcpp allows us to inject C++ code into R seamlessly. What's more, we will be capable of using R code directly in our C++ programs. 

A central topic that confuses many practitioners is that we will manipulate both C++ native variables (such as vectors, ints, doubles,etc.) and R specific variables such as NumericVectors,etc. We invest quite a lot of time explaining these two groups.

We show how to write C++ code in our R IDE, and how to load it externally via SourceCpp. 

With the Rcpp machinery we will know how to write super efficient code, appropriate for high performance computing.

We discuss more advanced topics in Rcp such as passing dataframes from R to C++, calling R functions in C++, etc.

The Rcpp sugar syntax allows us to write highly optimized vectorized code in C++, which will make us doubt whether we are writing C++ or R code! Remember that vectorized operations are not included per se, in C++

We discuss several sugar strategies and operators. At the end, we will be able to write our C++ code using much less syntax.

This is by far the most challenging and technical part of this course. We will show how to run parallel C++ code via OMP through Rcpp. The result? Code that runs up to 6X faster depending on how many cores your PC has.

We introduce one example using parallel fors. In particular we show a quite complicated example where we want to do a reduction using parallel for. The problem in this case is that we will encounter lots of synchronization problems, unless we either: 

a) declare the main operation as atomic and use private variables

b) declare everything as a reduction.

Mastering OpenMP takes a lot of time, but this chapter will hopefully be enough to teach the elemental concepts of designing a parallel C++ program.

Python cannot be called from R so easily in Windows (we do have good packages but they work only in Linux). In this lecture, we develop R code that writes instructions to a file and then calls Python via batch mode. In that way we can share files and programs, operating in R, in a quite easy way. 

R can easily be called from Python using an appropriate package. This means that we can leverage some excellent R functions directly in Python. 

Python is a more advanced programming language which is more powerful, but it lacks the same statistical power that R has.

In this lecture we create Python code that reads and sends data into R, and then receives data from R. We show how the statistical capabilities of R can be taken to the next level when we create the corresponding Python classes. In particular, we develop a histogram() Python class that is fed from the histogram created in R.

We show how to call Java code from R via the RJava package. We create specific classes in Java via Eclipse, and then add them to the java classpath. We then instantiate multiple Java classes and store them in a list. We also discuss some basic Java classes fundamentals. This approach allows us to encapsulate R data into proper Java classes which can help organize our data and functions in a better way 

We show how to call R directly from Java via the Rserve package. We run this example using Eclipse and Windows 10.

sqldf allows us to use sql syntax directly on R dataframes. Thus, we can easily build very complex queries, that would otherwise require a lot of cumbersome R notation. We discuss the basic sqldf operations, filtering, ordering, transposing. And how to execute queries on data frames

We use sqldf for more realistic applications, such as merging data from different dataframes. 

We review the Full vs Inner vs Left vs Right join. We end up using a customised approach to simulate a full join on sqldf, and can also be extended for finding observations in one table and not in the other one.