1. Python and MySQL references.
2. Calling R from C.
3. Calling C++ from R.

3. Python and MySQL references.
For Python, a nice introduction is 
  http://www.rexx.com/~dkuhlman/python_101/python_101.html . There are 
many nearly equivalent online references. Another nice one is 
  http://wiki.python.org/moin/BeginnersGuide
For MySQL, a good reference is
  King, T., Reese, G., Yarger, R., and Williams, H.E. (2002).
  Managing and Using MySQL: Open Source SQL Databases for Managing Information 
  and Web Sites, 2nd ed. O'Reilly and Associates, Inc., Sebastopol, CA.
  Or 
  Sams Teach Yourself SQL in 10 Minutes, http://www.amazon.com/dp/0672325675,
and websites that you might like are
  http://w3schools.com/php/php_mysql_intro.asp
  http://www.tizag.com/mysqlTutorial or
  http://www.keithjbrown.co.uk/vworks/mysql .

2. Calling R from C.

Notes on this come from Phil Spector's lecture notes at UC Berkeley.

The composite version of Simpson's rule is a rough way to approximate 
an integral of some function, f.
It goes back to English mathematician Thomas Simpson (1710Ð1761), who 
approximated the integral from a to b of f(x) dx by 
[(b-a)/6] [f(a) + 4f((a+b)/2) + f(b)].
This is the approximation you'd get by just dividing the interval (a,b) 
into 6 pieces, and using the left endpoint for the first piece, the right 
endpoint for the last piece, and the middle, (a+b)/2, for the other 4 
pieces. 

For the composite Simpson's rule, you divide the interval not into 
6 pieces but n pieces, where n is even, and get
the integral from a to b of f(x) dx ~
  h/3 [f(a) + 4f(a+h) + 2f(a+2h) + 4f(a+3h) + 2f(a+4h) + ... + 4f(b-h) + f(b)],
where h = (b-a)/n.
Note that the coefficients 4 and 2 alternate.
The error in Simpson's rule is bounded in absolute value by 
h^4 (b-a) max[f^4(x); x in (a,b)]/180.

Suppose we want to write this function f in R, but run the composite Simpson's
rule in C, and call the C function from R.
The key component is a C function called call_R. call_R takes as one of its 
arguments a pointer to a function, which is passed into the C environment 
as a list. The number and type of the arguments to f are also passed to call_R. 
As usual, when calling C from R, the results of the C function in the end are 
passed back to R not as a returned value, but through the argument list. 

It is typically easiest to divide the C program into three parts.
1) simp is the algorithm to implement the composite Simpson's rule, 
but it doesn't deal with issues pertaining to the interface between C and R.
2) sfunc is just a shell that uses call_R to have R evaluate the function f.
3) dosimp is just the interface, which is called by R and which calls simp.

In simp.c,

  static char *sfunction; 

 double simp(double(*func)(),double start,double stop,long n)
{
    double mult,x,t,t1,inc; 
    long i; 
    inc = (stop - start) / (double)n; 
    x = start;
    t = func(x); 
    mult = 4.0; 
    for(i=1; i<n; i++){
	x += inc; 
	t += mult * func(x); 
	if(mult == 4.0) mult = 2.0;
	else mult = 4.0;
    }
    t += func(stop); 
    return(t * inc / 3.0); 
}

  double sfunc(double x) {
    char *modes[1]; 
    char *arguments[1]; 
    double *result; 
    long lengths[2]; 
    lengths[0] = (long)1; 
    arguments[0] = (char*)&x; 
    modes[0] = "double"; 
    call_R(sfunction,(long)1,arguments,modes,lengths,
	   (char*)0,(long)1,arguments); 
	   result = (double*)arguments[0]; 
	   return(*result); 
  }

  dosimp(char** funclist,double *start,double *stop,long *n,double *answer) {
    double sfunc(double); 
    double simp(double(*)(),double,double,long); 
    sfunction = funclist[0]; 
    *answer = simp((double(*)())sfunc,*start,*stop,*n); 
  } 
	   
The function simp implements the composite Simpson's rule.

The function dosimp is what R calls.
dosimp simply extracts the function pointer from the list passed into the C 
environment, and loads it into a static pointer to make it available to the 
function sfunc, and then calls the function simp which actually does the integration. 

sfunc uses the call_R function to pass arguments to, and receive results from, R. 
call_R's first argument is the pointer to the function which was passed to dosimp from R. 
The second argument is the number of arguments to be passed to the R 
function, which in this case is 1. (long 1 just means the integer 1.)
Next is an array of pointers to the arguments themselves, each cast as char*. 
Note that this is an array of pointers, i.e. a pointer to pointers.
Similarly, the modes argument is an array of pointers to character strings 
that tell the R function how to treat each argument, i.e. as doubles, 
integers, etc. The most common modes are double and character. 
As in all functions external to R, the arguments themselves are pointers 
to the values they represent, not the values themselves. 
The next argument is an array of integers (longs) giving the length of 
each of the arguments passed; in this case, lengths[0] has been set to 1. 
The next argument, which is cast as a null pointer in this example, 
is a pointer to an array of names of the arguments being passed 
to the R function; usually an explicit pointer to names will not 
be required. The next argument is the number of results which the 
R function will return; by returning a list, an R function can return 
more than one value into the C environment. 
The final argument is an array of pointers to where the results will be returned. 

Now, in R,
  system("R CMD SHLIB simp.c")
  dyn.load("simp.so")
  mysimp = function(func, start, stop, n = 10) {
    if(trunc(n/2) - n/2 != 0) stop("Number of points must be even.")
    t=0 
    .C("dosimp",list(func),as.double(start),
    as.double(stop),as.integer(n), ans = as.double(t))$ans
  }
  f1 = function(x){x^4 - 2*x^2}
  mysimp(f1,1,4,10)  ## compare with 4^5/5 - 1/5 - 2*4^3/3 + 2/3 = 162.6.
  mysimp(f1,1,4,100)

Note the use of list(func). This passes the function pointer to the C routine.

3. Calling C++ from R.

C++ code is called exactly like C code, and for the most part, 
and while c++ files usually end in .cpp rather than .c,
modern compilers like Xcode usually are able to interpret the code
equivalently regardless of the file name.

For instance, here is mypi.c, from lecture 10.

#include <R.h>
#include <Rmath.h>
void pi2 (int *n, double *y){
    int i;
    double x[*n];
    x[0] = 1.0;
    y[0] = sqrt(6.0);
    for(i = 1; i < *n; i++) {
	x[i] = x[i-1] + 1.0 / ((i+1.0)*(i+1.0));
	/* or x[i] = x[i-1] + 1.0 / pow(i+1.0,2.0); */
	y[i] = sqrt(6.0 * x[i]);
    }
}

    system("R CMD SHLIB mypi.c")
    dyn.load("mypi.so")
    b = .C("pi2",as.integer(1000000), y = double(1000000))
    b$y[1000000]

I took the same file and called it mypi5.cpp.

    system("R CMD SHLIB mypi5.cpp")
    dyn.load("mypi5.so")
    b = .C("pi2",as.integer(1000000), y = double(1000000))
    b$y[1000000]

So, C code works in C++.
Now let's change some things in mypi5.cpp.

#include <R.h>
#include <Rmath.h>
void pi2 (int *n, double *y){
    // int i;           // I removed this.
    double x[*n];
    x[0] = 1.0;
    y[0] = sqrt(6.0);
    int i;              // and added it here.
    for(i = 1; i < *n; i++) {
	x[i] = x[i-1] + 1.0 / ((i+1.0)*(i+1.0));
	/* or x[i] = x[i-1] + 1.0 / pow(i+1.0,2.0); */
	y[i] = sqrt(6.0 * x[i]);
    }
}

    system("R CMD SHLIB mypi5.cpp")
    dyn.load("mypi5.so")
    b = .C("pi2",as.integer(1000000), y = double(1000000))
    b$y[1000000]

If we tried this in C, we'd get an error.

Next we will discuss fitting models by maximum likelihood,
using optim() in R, and C for the likelihood function.