The constraint on proportions means that the mixture data can be described in one dimension lower than the total number of components. For example when there are three mixture components a two dimension plot can be used to represent the mixture within an equilateral triangle.

To create a surface within the mixture triangle we can create a grid of points and then convert these pairs of points into mixture triples.

mygrid = rbind(
	expand.grid(
		x = seq(0, 1.0, length.out = 500),
		y = seq(0, sqrt(3)/2, length.out = 500)
	)
)

The conversion formulae are shown below:

mygrid$a = (sqrt(3) * (mygrid$x - 0.5) + (mygrid$y - 0.5 * sqrt(3))) /
  (- sqrt(3) - 0.5 * sqrt(3))
mygrid$b = (- sqrt(3) * (mygrid$x - 0.5) + (mygrid$y - 0.5 * sqrt(3))) /
  (- sqrt(3) - 0.5 * sqrt(3))
mygrid$c = 1 - mygrid$a - mygrid$b

The next step is to calculate our surface values, a trivial example of which is:

mygrid$z = 10 + 4 * mygrid$a + 3 * mygrid$b

We then need to trick the plotting function by setting all invalid mixture combinations to be missing values.

mygrid$z[mygrid$a < 0 | mygrid$b < 0 | mygrid$c < 0] = NA
mygrid$z[mygrid$a > 1 | mygrid$b > 1 | mygrid$c > 1] = NA

Lastly we use the levelplot function in the lattice package.

trellis.par.set("axis.line",list(col=NA,lty=1,lwd=1))
levelplot(z ~ x*y, data = mygrid,
	col.regions = gray(101:0/101), scales = list(draw=FALSE),
	xlab = "", ylab = "",
	panel = function(x, y, z, ...)
	{
		panel.levelplot(x, y, z, ...)
		panel.lines(c(0,1), c(0,0), col = "black")
		panel.lines(c(0,0.5), c(0,sqrt(3)/2), col = "black")
		panel.lines(c(0.5,1), c(sqrt(3)/2,0), col = "black")
		panel.text(0.5, sqrt(3)/2, "C", pos=3)
		panel.text(0, 0, "A", pos=2)
		panel.text(1, 0, "B", pos=4)
	},
	xlim = c(-0.2,1.2),
	ylim = c(-0.2, 0.2+sqrt(3)/2)
)

This forms the basis of a ternary surface plot and various adjustments can be easily made to customise the plot.

Example of a surface plot in a ternary diagram

Other useful resources are provided on the Supplementary Material page.

It is difficult to specify a set of criteria to determine whether a player can be described as an all-rounder. To compare the performances of various all-rounders we can look at the subset of crickters who have scored at least 1,000 runs and taken at least 100 wickets at Test Match level. This is not a perfect criteria as there will be players who have taken part in sufficient test matches that they will be included even though they are clearly much stronger in one of the two disciplines but very handy in the other.

A total of 54 test match cricketers were identified based on this criteria (up to and including test match 2004) and a scatter plot of the performances can be seen here. The graph shows that the majority of players in the bottom left region of the graph with a handful of batsmen and bowlers at the extremes in terms of runs or wickets.

To get a better idea of the balance between wickets and runs we can zoom in on the bottom left hand region of the graph to get this display. This new graph suggests that although there have been a number of English cricketers that has scored 1,000 runs and taken 100 wickets they do not have the longevity of players from other countries.

There are naturally other measures of performance that could be used to compare this set of allround cricketers which might provided a more illuminating insight into all round performances.

The stringr package has a handy function str_trim (edited) that comes to the rescue and is straightforward to use. First up make sure that the package is available in the R session:

require(stringr)

Here is a basic example with a simple string:

> "  This is an example of whitespace.  "
[1] "  This is an example of whitespace.  "
> str_trim("  This is an example of whitespace.  ")
[1] "This is an example of whitespace."

As we can see this is very simple and is set up to work on a vector of character strings as well.

Other useful resources are provided on the Supplementary Material page. Visit here for more examples of string manipulation.

Some examples of using R.NET can be found here and here.

Fast Tube by Casper

To investigate using Poisson regression via the GLM framework consider a small data set on failure modes (here).

> failure.df = read.table("twomodes.dat", header = TRUE)
> failure.df
  Mode1 Mode2 Failures
1  33.3  25.3       15
2  52.2  14.4        9
3  64.7  32.5       14
4 137.0  20.5       24
5 125.9  97.6       27
6 116.3  53.6       27
7 131.7  56.6       23
8  85.0  87.3       18
9  91.9  47.8       22

The machinery is run in two modes and the objective of the analysis is to determine whether the number of failures depends on how long the machine is run in mode 1 or mode 2 and whether there is an interaction between the time in each mode to increases or decreases the number of failures.

The response for this set of data is the number of failures (count) so a Poisson regression model is considered.

> fmod1 = glm(Failures ~ Mode1 * Mode2, data = failure.df, family = poisson)
> summary(fmod1)
 
Call:
glm(formula = Failures ~ Mode1 * Mode2, family = poisson, data = failure.df)
 
Deviance Residuals: 
       1         2         3         4         5         6         7         8         9  
 0.91003  -1.15601  -0.28328  -0.10398   0.03526   0.84825  -0.49211  -0.57298   0.64821  
 
Coefficients:
              Estimate Std. Error z value Pr(>|z|)    
(Intercept)  2.105e+00  4.481e-01   4.698 2.63e-06 ***
Mode1        7.687e-03  4.285e-03   1.794   0.0729 .  
Mode2        4.703e-03  1.163e-02   0.405   0.6858    
Mode1:Mode2 -1.978e-05  1.037e-04  -0.191   0.8487    
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
(Dispersion parameter for poisson family taken to be 1)
 
    Null deviance: 16.996  on 8  degrees of freedom
Residual deviance:  3.967  on 5  degrees of freedom
AIC: 55.024
 
Number of Fisher Scoring iterations: 4

The model output does not provide any support for an interaction between the number of time spent in the two different modes of operation. If we remove the interaction term and re-fit the model, using the update function, we get:

> fmod2 = update(fmod1, . ~ . - Mode1:Mode2)
> summary(fmod2)
 
Call:
glm(formula = Failures ~ Mode1 + Mode2, family = poisson, data = failure.df)
 
Deviance Residuals: 
     Min        1Q    Median        3Q       Max  
-1.21984  -0.44735  -0.05893   0.68351   0.87510  
 
Coefficients:
            Estimate Std. Error z value Pr(>|z|)    
(Intercept) 2.175168   0.255456   8.515  < 2e-16 ***
Mode1       0.007015   0.002429   2.888  0.00387 ** 
Mode2       0.002549   0.002835   0.899  0.36852    
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
(Dispersion parameter for poisson family taken to be 1)
 
    Null deviance: 16.9964  on 8  degrees of freedom
Residual deviance:  4.0033  on 6  degrees of freedom
AIC: 53.06
 
Number of Fisher Scoring iterations: 4

This output suggests that the time of operation in mode 1 is important for determining the number of faults but the time of operation in mode 2 is not important. One last step gives us:

> fmod3 = update(fmod2, . ~ . - Mode2)
> summary(fmod3)
 
Call:
glm(formula = Failures ~ Mode1, family = poisson, data = failure.df)
 
Deviance Residuals: 
     Min        1Q    Median        3Q       Max  
-1.43194  -0.56958  -0.00745   0.66742   0.82231  
 
Coefficients:
            Estimate Std. Error z value Pr(>|z|)    
(Intercept) 2.237196   0.243053   9.205  < 2e-16 ***
Mode1       0.007705   0.002264   3.403 0.000667 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1 
 
(Dispersion parameter for poisson family taken to be 1)
 
    Null deviance: 16.9964  on 8  degrees of freedom
Residual deviance:  4.8078  on 7  degrees of freedom
AIC: 51.865
 
Number of Fisher Scoring iterations: 4

The diagnostic plots are shown below which do not indicate any major problems with the final model, especially given the small number of data points.

Four diagnostic plots for a Poisson regression model based on total failures

Other useful resources are provided on the Supplementary Material page.

There are various functions available in R for dealing with errors and in this post we will consider some basic examples of how to make use of the try function.

To illustrate how to use try let’s look at what happens if we run code to print out a non-existent object in our workspace:

> print(d)
Error in print(d) : object 'd' not found

Now if we try to run another command at the same time to print out a string then we would get the following output:

> print(d); print("Hi")
Error in print(d) : object 'd' not found

Here execution of the code halts after the first command fails and generates an error. We can modify this code to call the try function with the print statement:

> try(print(d)); print("Hi")
Error in print(d) : object 'd' not found
[1] "Hi"

The second statement is now evaluated even though an error occurs at the first statement. This is a trivial example and in other situations we might consider using the tryCatch function which has various arguments in addition to the expression to evaluate including a function to be called when an error occurs.

Fast Tube by Casper

Other useful resources are provided on the Supplementary Material page.

There are some functions provided in R that could take away some of the pain. After setting our default repository we can use the available.packages function to generate a list of available packages (no surprise there) and then use the download.packages function to download them to a suitable directory on our PC.

> pkg.list = available.packages()
> download.packages(pkgs = pkg.list, destdir = "C:\\MyRPackages")

This will grab the list of available packages and download them to the directory C:\MyRPackages so that they can be installed as required or burnt to CD/DVD and transferred to the standalone PC.