The news of the new release of is out, and the is buzzing. Bloggers about the new R compiler package that brings with it the hope to speed up our R code with and even a JIT compiler for R牵手常德棋牌官方下载. So it is time to upgrade, and bloggers are here to help. Some wrote how to upgrade R on and (based on ). And it is now my turn, with suggestions on how to upgrade R on windows 7.

Upgrading R on windows – the two strategies

The classic description of how to upgrade R can be found in (and also the )

牵手常德棋牌官方下载There are basically two strategies for R upgrading on windows. The first is to install a new R version and copy paste all the packages to the new R installation folder. The second is to have a global R package folder, each time synced to the most current R installation (thus saving us the time of copying the package library each we upgrade R).

I described the second strategy in detail in a post I wrote a year ago titled: “How to upgrade R on windows XP – another strategy牵手常德棋牌官方下载” which explains how to upgrade R using the simple two-liner code:

p.s: If this is the first time you are upgrading R using this method, then first run the following two lines on your old R installation (before 牵手常德棋牌官方下载running the above code in the new R intallation):

The above code should be enough. However, there are some common pitfalls you might encounter when upgrading R on windows 7, bellow I outline the ones I know about, and how they can be solved.

牵手常德棋牌官方下载In 2002, published in “The Stata Journal” an article named “. As explained in the abstract:

In hierarchical cluster analysis dendrogram graphs are used to visualize how clusters are formed. I propose an alternative graph named “clustergram” to examine how cluster members are assigned to clusters as the number of clusters increases.
This graph is useful in exploratory analysis for non-hierarchical clustering algorithms like k-means and for hierarchical cluster algorithms when the number of observations is large enough to make dendrograms impractical.

A was later written and was (maybe) published in “computational statistics”.

Both articles gives some nice background to known methods like k-means and methods for hierarchical clustering, and then goes on to present examples of using these methods (with the Clustergarm) to analyse some datasets.

Personally, I understand the clustergram to be a type of parallel coordinates plot where each observation is given a vector. The vector contains the observation’s location according to how many clusters the dataset was split into. The scale of the vector is the scale of the first principal component of the data.

Clustergram in R (a basic function)

After finding out about this method of visualization, I was hunted by the curiosity to play with it a bit. Therefore, and since I didn’t find any implementation of the graph in R, I went about writing the code to implement it.

The code only works for kmeans, but it shows how such a plot can be produced, and could be later modified so to offer methods that will connect with different clustering algorithms.

How does the function work: The function I present here gets a data.frame/matrix with a row for each observation, and the variable dimensions present in the columns.
The function assumes the data is scaled.
The function then goes about calculating the cluster centers for our data, for varying number of clusters.
For each cluster iteration, the cluster centers are multiplied by the first loading of the principal components of the original data. Thus offering a weighted mean of the each cluster center dimensions that might give a decent representation of that cluster (this method has the known limitations of using the first component of a PCA for dimensionality reduction, but I won’t go into that in this post).
Finally all of our data points are ordered according to their respective cluster first component, and plotted against the number of clusters (thus creating the clustergram).

My thank goes to for offering some good tips on how to prepare the graph.

Here is the code (example follows)

The R function can be 牵手常德棋牌官方下载
Corrections and remarks can be added in the comments bellow, or on .

Example on the iris dataset

The is a favorite example of many when writing about , , , and for techniques.
So it seemed only natural to experiment on it here.

source("http://oi02img.icu/wp-content/uploads/2012/01/source_https.r.txt")# Making sure we can source code from github
source_https("http://raw.github.com/talgalili/R-code-snippets/master/clustergram.r")data(iris)set.seed(250)par(cex.lab=1.5, cex.main=1.2)
Data <-scale(iris[,-5])# notice I am scaling the vectors)
clustergram(Data, k.range=2:8, line.width=0.004)# notice how I am using line.width. Play with it on your problem, according to the scale of Y.

Here is the output:

Looking at the image we can notice a few interesting things. We notice that one of the clusters formed (the lower one) stays as is no matter how many clusters we are allowing (except for one observation that goes way and then beck).
We can also see that the second split is a solid one (in the sense that it splits the first cluster into two clusters which are not “close” to each other, and that about half the observations goes to each of the new clusters).
And then notice how moving to 5 clusters makes almost no difference.
Lastly, notice how when going for 8 clusters, we are practically left with 4 clusters (remember – this is according the mean of cluster centers by the loading of the first component of the PCA on the data)

牵手常德棋牌官方下载If I where to take something from this graph, I would say I have a strong tendency to use 3-4 clusters on this data.

But wait, did our clustering algorithm do a stable job?
Let’s try running the algorithm 6 more times (each run will have a different starting point for the clusters)

source("http://oi02img.icu/wp-content/uploads/2012/01/source_https.r.txt")# Making sure we can source code from github
source_https("http://raw.github.com/talgalili/R-code-snippets/master/clustergram.r")set.seed(500)
Data <-scale(iris[,-5])# notice I am scaling the vectors)par(cex.lab=1.2, cex.main= .7)par(mfrow =c(3,2))for(i in1:6) clustergram(Data, k.range=2:8 , line.width= .004, add.center.points=T)

牵手常德棋牌官方下载Resulting with: (press the image to enlarge it)

Repeating the analysis offers even more insights.
First, it would appear that until 3 clusters, the algorithm gives rather stable results.
From 4 onwards we get various outcomes at each iteration. 牵手常德棋牌官方下载
At some of the cases, we got 3 clusters when we asked for 4 or even 5 clusters.

Reviewing the new plots, I would prefer to go with the 3 clusters option. Noting how the two “upper” clusters might have similar properties while the lower cluster is quite distinct from the other two.

牵手常德棋牌官方下载By the way, the Iris data set is composed of three types of flowers. I imagine the kmeans had done a decent job in distinguishing the three.

Limitation of the method (and a possible way to overcome it?!)

It is worth noting that the current way the algorithm is built has a fundamental limitation: The plot is good for detecting a situation where there are several clusters but each of them is clearly “bigger” then the one before it (on the first principal component of the data).

牵手常德棋牌官方下载For example, let’s create a dataset with 3 clusters, each one is taken from a normal distribution with a higher mean:

source("http://oi02img.icu/wp-content/uploads/2012/01/source_https.r.txt")# Making sure we can source code from github
source_https("http://raw.github.com/talgalili/R-code-snippets/master/clustergram.r")set.seed(250)
Data <-rbind(cbind(rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3)),
cbind(rnorm(100,1, sd=0.3),rnorm(100,1, sd=0.3),rnorm(100,1, sd=0.3)),
cbind(rnorm(100,2, sd=0.3),rnorm(100,2, sd=0.3),rnorm(100,2, sd=0.3)))
clustergram(Data, k.range=2:5 , line.width= .004, add.center.points=T)

The resulting plot for this is the following:

The image shows a clear distinction between three ranks of clusters. There is no doubt (for me) from looking at this image, that three clusters would be the correct number of clusters.

But what if the clusters where different but didn’t have an ordering to them? 牵手常德棋牌官方下载
For example, look at the following 4 dimensional data:

source("http://oi02img.icu/wp-content/uploads/2012/01/source_https.r.txt")# Making sure we can source code from github
source_https("http://raw.github.com/talgalili/R-code-snippets/master/clustergram.r")set.seed(250)
Data <-rbind(cbind(rnorm(100,1, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3)),
cbind(rnorm(100,0, sd=0.3),rnorm(100,1, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3)),
cbind(rnorm(100,0, sd=0.3),rnorm(100,1, sd=0.3),rnorm(100,1, sd=0.3),rnorm(100,0, sd=0.3)),
cbind(rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,0, sd=0.3),rnorm(100,1, sd=0.3)))
clustergram(Data, k.range=2:8 , line.width= .004, add.center.points=T)

In this situation, it is not clear from the location of the clusters on the Y axis that we are dealing with 4 clusters.
But what is interesting, is that through the growing number of clusters, we can notice that there are 4 “strands” of data points moving more or less together (until we reached 4 clusters, at which point the clusters started breaking up).
Another hope for handling this might be using the color of the lines in some way, but I haven’t yet figured out how.

Clustergram with ggplot2

has kindly played with recreating the clustergram using the ggplot2 engine. You can see the result here:

牵手常德棋牌官方下载
And this is what he wrote about it in the comments:

I’ve broken it down into three components:
* run the clustering algorithm and get predictions (many_kmeans and all_hclust)
* produce the data for the clustergram (clustergram)
* plot it (plot.clustergram)
I don’t think I have the logic behind the y-position adjustment quite right though.

Conclusions (some rules of thumb and questions for the future)

牵手常德棋牌官方下载In a first look, it would appear that the clustergram can be of use. I can imagine using this graph to quickly run various clustering algorithms and then compare them to each other and review their stability (In the way I just demonstrated in the example above).

牵手常德棋牌官方下载The three rules of thumb I have noticed by now are:

Look at the location of the cluster points on the Y axis. See when they remain stable, when they start flying around, and what happens to them in higher number of clusters (do they re-group together)

Observe the strands of the datapoints. Even if the clusters centers are not ordered, the lines for each item might (needs more research and thinking) tend to move together – hinting at the real number of clusters

Run the plot multiple times to observe the stability of the cluster formation (and location)

Yet there is more work to be done and questions to seek answers to:

The code needs to be extended to offer methods to various clustering algorithms.

How can the colors of the lines be used better?

How can this be done using other graphical engines (ggplot2/lattice?) – (Update: look at Hadley’s reply in the comments)

What to do in case the first principal component doesn’t capture enough of the data? (maybe plot this graph to all the relevant components. but then – how do you make conclusions of it?)

What other uses/conclusions can be made based on this graph?

牵手常德棋牌官方下载I am looking forward to reading your input/ideas in the comments (or in reply posts).

Update: This post has a follow-up for how to upgrade R on windows 7 explaining how to deal with permission issues.

Background – how I heard that there is more then one way to upgrade R

If you didn’t now – with a bunch of new features.

牵手常德棋牌官方下载After recently lamented the lack of an easy upgrade process for R, a (by JD Long) invited R users to share their strategies for easily upgrading R.

Upgrading strategy – moving to a global R library

In that thread, suggested another idea for upgrading R. His idea is of using a folder for R’s packages which is outside the standard directory tree of the installation (a different strategy then the one ).

The idea of this upgrading strategy is to save us steps in upgrading. So when you wish to upgrade R, instead of doing the following three steps:

download new R and install

copy the “library” content from the old R to the new R

upgrade all of the packages (in the library folder) to the new version of R.

You could instead just have steps 1 and 3, and skip step 2牵手常德棋牌官方下载 (thus, saving us time…).

For example, under windows XP, you might have R installed on: C:Program FilesRR-2.11.0
But (in this alternative model for upgrading) you will have your packages library on a “global library folder” (global in the sense of independent of a specific R version): C:Program FilesRlibrary

So in order to use this strategy, you will need to do the following steps (all of them are performed in an R code provided later in the post)-

In the OLD R installation (in the first time you move to the new system of managing the upgrade):

Create a new global library folder (if it doesn’t exist)

Copy to the new “global library folder” all of your packages from the old R installation

After you move to this system – the steps 1 and 2 would not need to be repeated. (hence the advantage)

In the NEW R installation:

Create a new global library folder (if it doesn’t exist – in case this is your first R installation)

Premenantly point to the Global library folder whenever R starts

(Optional) Delete from the “Global library folder” all the packages that already exist in the local library folder of the new R install (no need to have doubles)

Update all packages. (notice that you picked a mirror where the packages are up-to-date, you sometimes need to choose another mirror)

牵手常德棋牌官方下载Thanks to , David Winsemius and Uwe Ligges, I was able to write the following R code to perform all the tasks I described 🙂

牵手常德棋牌官方下载When analyzing a questionnaire, one often wants to view the correlation between two or more item’s (for example: two ordered categorical vectors ranging from 1 to 5).

When dealing with several such Likert variable’s, a clear presentation of all the pairwise relation’s between our variable can be achieved by inspecting the (Spearman) correlation matrix (easily achieved in R by using the “cor.test” command on a matrix of variables).
Yet, a challenge appears once we wish to plot this correlation matrix. The challenge stems from the fact that the classic presentation for a correlation matrix is a scatter plot matrix – but scatter plots don’t (usually) work well for ordered categorical vectors since the dots on the scatter plot often overlap each other.

There are four solution for the point-overlap problem that I know of:

Jitter the data a bit to give a sense of the “density” of the points

Use a color spectrum to represent when a point actually represent “many points”

Use different points sizes to represent when there are “many points” in the location of that point

Add a LOWESS (or LOESS) line to the scatter plot – to show the trend of the data

In this post I will offer the code for the a solution that uses solution 3-4 (and possibly 2, please read this post comments). Here is the output (click to see a larger image):

牵手常德棋牌官方下载In this post I will provide R code that implement’s the combination of repeated running quantile with the LOESS smoother to create a type of “quantile LOESS” (e.g: “Local Quantile Regression”).

This method is useful when the need arise to fit robust and resistant (Need to be verified)牵手常德棋牌官方下载 a smoothed line for a quantile (an example for such a case is provided at the end of this post).

If you wish to use the function in your own code, simply run inside your R console the following line:

牵手常德棋牌官方下载I came a cross this idea in an article titled “” by Anat Sakov, Ilan Golani, Dina Lipkind and my advisor Yoav Benjamini. From the abstract:

In recent years, a growing need has arisen in different fields, for the development of computational systems for automated analysis of large amounts of data (high-throughput). Dealing with non-standard noise structure and outliers, that could have been detected and corrected in manual analysis, must now be built into the system with the aid of robust methods. […] we use a non-standard mix of robust and resistant methods: LOWESS and repeated running median.

The motivation for this technique came from “Path data” (of mice) which is

prone to suffer from noise and outliers. During progression a tracking system might lose track of the animal, inserting (occasionally very large) outliers into the data. During lingering, and even more so during arrests, outliers are rare, but the recording noise is large relative to the actual size of the movement. The statistical implications are that the two types of behavior require different degrees of smoothing and resistance. An additional complication is that the two interchange many times throughout a session. As a result, the statistical solution adopted needs not only to smooth the data, but also to recognize, adaptively, when there are arrests. To the best of our knowledge, no single existing smoothing technique has yet been able to fulfill this dual task. We elaborate on the sources of noise, and propose a mix of LOWESS (Cleveland, 1977) and the repeated running median (RRM; Tukey, 1977) to cope with these challenges

If all we wanted to do was to perform (running average) on the data, using R, we could simply use the rollmean function from the .
But since we wanted also to allow quantile smoothing, we turned to use the rollapply function.

R function for performing Quantile LOESS

牵手常德棋牌官方下载Here is the R function that implements the LOESS smoothed repeated running quantile (with implementation for using this with a simple implementation for using average instead of quantile):

In this post I showcase a nice bar-plot and a balloon-plot listing recommended Nutritional supplements , according to how much evidence exists for thier benefits, scroll down to see it(and for the data behind it)
* * * *
The gorgeous blog recently publish an showing a “balloon race” image (see a static version of the image ) illustrating how much evidence exists for the benefits of various Nutritional supplements (such as: green tea, vitamins, herbs, pills and so on) . The higher the bubble in the Y axis score (e.g: the bubble size)牵手常德棋牌官方下载 for the supplement the greater the evidence there is for its effectiveness (But only for the conditions listed along side the supplement).

There are two reasons this should be of interest to us:

This shows a fun plot, that R currently doesn’t know how to do (at least I wasn’t able to find an implementation for it). So if anyone thinks of an easy way for making one – please let me know.

The data for the graph is openly (and freely) provided to all of us on .

The advantage of having the data on a google doc means that we can see when the data will be updated. But more then that, it means we can easily extract the data into R and have our way with it (Thanks to on the subject)

For example, I was wondering what are ALL of the top recommended Nutritional supplements, an answer that is not trivial to get from the plot that was in the .

In this post I will supply two plots that present the data: A barplot (that in retrospect didn’t prove to be good enough) and a balloon-plot for a table (that seems to me to be much better).

Barplot
(You can click the image to enlarge it)

The R code to produce the barplot of Nutritional supplements efficacy score (by evidence for its effectiveness on the listed condition).

# loading the data
supplements.data.0 <-read.csv("http://spreadsheets.google.com/pub?key=0Aqe2P9sYhZ2ndFRKaU1FaWVvOEJiV2NwZ0JHck12X1E&output=csv")
supplements.data<- supplements.data.0[supplements.data.0[,2]>2,]# let's only look at "good" supplements
supplements.data<- supplements.data[!is.na(supplements.data[,2]),]# and we don't want any missing data
supplement.score<- supplements.data[, 2]
ss <-order(supplement.score, decreasing =F)# sort our data
supplement.score<- supplement.score[ss]
supplement.name<- supplements.data[ss, 1]
supplement.benefits<- supplements.data[ss, 4]
supplement.score.col<-factor(as.character(supplement.score))levels(supplement.score.col)<-c("red", "orange", "blue", "dark green")
supplement.score.col<-as.character(supplement.score.col)# mar: c(bottom, left, top, right) The default is c(5, 4, 4, 2) + 0.1.par(mar =c(5,9,4,13))# taking care of the plot margins
bar.y<-barplot(supplement.score, names.arg= supplement.name, las =1, horiz =T, col= supplement.score.col, xlim =c(0,6.2),
main =c("Nutritional supplements efficacy score","(by evidence for its effectiveness on the listed condition)", "(2010)"))axis(4, labels= supplement.benefits, at = bar.y, las =1)# Add right axisabline(h = bar.y, col= supplement.score.col , lty =2)# add some lines so to easily follow each bar

牵手常德棋牌官方下载Also, the nice things is that if the guys at Information Is Beautiful will update there data, we could easily run the code and see the updated list of recommended supplements.

Balloon plot
So after some web surfing I came around an implementation of a balloon plot in R (Thanks to ) 牵手常德棋牌官方下载
There where two problems with using the command out of the box. The first one was that the colors where non informative (easily fixed), the second one was that the X labels where overlapping one another. Since there is no “las” parameter in the function, I just opened the function up, found where this was plotted and changed it manually (a bit messy, but that’s what you have to do sometimes…)

Here are the result (you can click the image for a larger image):

And here is The R code to produce the Balloon plot of Nutritional supplements efficacy score (by evidence for its effectiveness on the listed condition). 牵手常德棋牌官方下载
(it’s just the copy of the function with a tiny bit of editing in line 146, and then using it)

Daniel Malter just shared on the R mailing list () his code for performing the Siegel-Tukey (Nonparametric) test for equality in variability.
Excited about the find, I contacted Daniel asking if I could republish his code here, and he kindly replied “yes”. 牵手常德棋牌官方下载
From here on I copy his note at full.

The R function can be
Corrections and remarks can be added in the comments bellow, or on .

My goal in this post is to give an overview of Friedman’s Test and then offer R code to perform post hoc analysis on Friedman’s Test results. (The R function can be downloaded from here)

Preface: What is Friedman’s Test

Friedman test is a non-parametric randomized block analysis of variance. Which is to say it is a non-parametric version of a one way ANOVA with repeated measures. That means that while a simple ANOVA test requires the assumptions of a normal distribution and equal variances (of the residuals), the Friedman test is free from those restriction. The price of this parametric freedom is the loss of power (of Friedman’s test compared to the parametric ANOVa versions).

The hypotheses for the comparison across repeated measures are:

H0: The distributions (whatever they are) are the same across repeated measures

H1: The distributions across repeated measures are different

The test statistic for the Friedman’s test is a Chi-square with [(number of repeated measures)-1] degrees of freedom. A detailed explanation of the method for computing the Friedman test is available .

Performing Friedman’s Test in R牵手常德棋牌官方下载 is very simple, and is by using the “friedman.test” command.

Post hoc analysis for the Friedman’s Test

Assuming you performed Friedman’s Test and found a significant P value, that means that some of the groups in your data have different distribution from one another, but you don’t (yet) know which. Therefor, our next step will be to try and find out which pairs of our groups are significantly different then each other. But when we have N groups, checking all of their pairs will be to perform [n over 2] comparisons, thus the need to correct for multiple comparisons arise. The tasks: Our first task will be to perform a post hoc analysis of our results (using R) – in the hope of finding out which of our groups are responsible that we found that the null hypothesis was rejected. While in the simple case of ANOVA, an R command is readily available (“TukeyHSD”), in the case of friedman’s test (until now) the code to perform the post hoc test was not as easily accessible. Our second task will be to visualize our results. While in the case of simple ANOVA, a boxplot of each group is sufficient, in the case of a repeated measures – a boxplot approach will be misleading to the viewer. Instead, we will offer two plots: one of parallel coordinates, and the other will be boxplots of the differences between all pairs of groups (in this respect, the post hoc analysis can be thought of as performing paired wilcox.test with correction for multiplicity).

R code for Post hoc analysis for the Friedman’s Test

The analysis will be performed using the function (I wrote) called “friedman.test.with.post.hoc”, based on the packages “coin” and “multcomp”. Just a few words about it’s arguments:

formu – is a formula object of the shape: Y ~ X | block (where Y is the ordered (numeric) responce, X is a group indicator (factor), and block is the block (or subject) indicator (factor)

data – is a data frame with columns of Y, X and block (the names could be different, of course, as long as the formula given in “formu” represent that)

All the other parameters are to allow or suppress plotting of the results.

friedman.test.with.post.hoc<-function(formu, data, to.print.friedman=T, to.post.hoc.if.signif=T, to.plot.parallel=T, to.plot.boxplot=T, signif.P= .05, color.blocks.in.cor.plot=T, jitter.Y.in.cor.plot=F){# formu is a formula of the shape: Y ~ X | block# data is a long data.frame with three columns: [[ Y (numeric), X (factor), block (factor) ]]# Note: This function doesn't handle NA's! In case of NA in Y in one of the blocks, then that entire block should be removed.# Loading needed packagesif(!require(coin)){print("You are missing the package 'coin', we will now try to install it...")install.packages("coin")library(coin)}if(!require(multcomp)){print("You are missing the package 'multcomp', we will now try to install it...")install.packages("multcomp")library(multcomp)}if(!require(colorspace)){print("You are missing the package 'colorspace', we will now try to install it...")install.packages("colorspace")library(colorspace)}# get the names out of the formula
formu.names<-all.vars(formu)
Y.name<- formu.names[1]
X.name<- formu.names[2]
block.name<- formu.names[3]if(dim(data)[2]>3)data<-data[,c(Y.name,X.name,block.name)]# In case we have a "data" data frame with more then the three columns we need. This code will clean it from them...# Note: the function doesn't handle NA's. In case of NA in one of the block T outcomes, that entire block should be removed.# stopping in case there is NA in the Y vectorif(sum(is.na(data[,Y.name]))>0)stop("Function stopped: This function doesn't handle NA's. In case of NA in Y in one of the blocks, then that entire block should be removed.")# make sure that the number of factors goes with the actual values present in the data:data[,X.name]<-factor(data[,X.name])data[,block.name]<-factor(data[,block.name])
number.of.X.levels<-length(levels(data[,X.name]))if(number.of.X.levels==2){warning(paste("'",X.name,"'", "has only two levels. Consider using paired wilcox.test instead of friedman test"))}# making the object that will hold the friedman test and the other.
the.sym.test<- symmetry_test(formu, data=data, ### all pairwise comparisons
teststat ="max",
xtrafo =function(Y.data){ trafo( Y.data, factor_trafo =function(x){model.matrix(~ x -1)%*%t(contrMat(table(x), "Tukey"))})},
ytrafo =function(Y.data){ trafo(Y.data, numeric_trafo =rank, block =data[,block.name])})# if(to.print.friedman) { print(the.sym.test) }if(to.post.hoc.if.signif){if(pvalue(the.sym.test)< signif.P){# the post hoc test
The.post.hoc.P.values<- pvalue(the.sym.test, method ="single-step")# this is the post hoc of the friedman test# plottingif(to.plot.parallel& to.plot.boxplot)par(mfrow =c(1,2))# if we are plotting two plots, let's make sure we'll be able to see bothif(to.plot.parallel){
X.names<-levels(data[, X.name])
X.for.plot<-seq_along(X.names)
plot.xlim<-c(.7 , length(X.for.plot)+.3)# adding some spacing from both sides of the plotif(color.blocks.in.cor.plot){
blocks.col<- rainbow_hcl(length(levels(data[,block.name])))}else{
blocks.col<-1# black}
data2 <-dataif(jitter.Y.in.cor.plot){
data2[,Y.name]<-jitter(data2[,Y.name])
par.cor.plot.text<-"Parallel coordinates plot (with Jitter)"}else{
par.cor.plot.text<-"Parallel coordinates plot"}# adding a Parallel coordinates plotmatplot(as.matrix(reshape(data2, idvar=X.name, timevar=block.name,
direction="wide")[,-1]) ,
type ="l", lty =1, axes = FALSE, ylab = Y.name,
xlim = plot.xlim,
col= blocks.col,
main = par.cor.plot.text)axis(1, at = X.for.plot , labels= X.names)# plot X axisaxis(2)# plot Y axispoints(tapply(data[,Y.name], data[,X.name], median) ~ X.for.plot, col="red",pch =4, cex =2, lwd =5)}if(to.plot.boxplot){# first we create a function to create a new Y, by substracting different combinations of X levels from each other.
subtract.a.from.b<-function(a.b , the.data){
the.data[,a.b[2]]- the.data[,a.b[1]]}
temp.wide<-reshape(data, idvar=X.name, timevar=block.name,
direction="wide")#[,-1]
wide.data<-as.matrix(t(temp.wide[,-1]))colnames(wide.data)<- temp.wide[,1]
Y.b.minus.a.combos<-apply(with(data,combn(levels(data[,X.name]), 2)), 2, subtract.a.from.b, the.data=wide.data)
names.b.minus.a.combos<-apply(with(data,combn(levels(data[,X.name]), 2)), 2, function(a.b){paste(a.b[2],a.b[1],sep=" - ")})
the.ylim<-range(Y.b.minus.a.combos)
the.ylim[2]<- the.ylim[2]+max(sd(Y.b.minus.a.combos))# adding some space for the labels
is.signif.color<-ifelse(The.post.hoc.P.values< .05 , "green", "grey")boxplot(Y.b.minus.a.combos,
names= names.b.minus.a.combos ,
col= is.signif.color,
main ="Boxplots (of the differences)",
ylim = the.ylim)legend("topright", legend=paste(names.b.minus.a.combos, rep(" ; PostHoc P.value:", number.of.X.levels),round(The.post.hoc.P.values,5)) , fill = is.signif.color)abline(h =0, col="blue")}
list.to.return<-list(Friedman.Test= the.sym.test, PostHoc.Test= The.post.hoc.P.values)if(to.print.friedman){print(list.to.return)}return(list.to.return)}else{print("The results where not significant, There is no need for a post hoc test")return(the.sym.test)}}# Original credit (for linking online, to the package that performs the post hoc test) goes to "David Winsemius", see:# http://tolstoy.newcastle.edu.au/R/e8/help/09/10/1416.html}

Example

牵手常德棋牌官方下载(The code for the example is given at the end of the post)

牵手常德棋牌官方下载Let’s make up a little story: let’s say we have three types of wine (A, B and C), and we would like to know which one is the best one (in a scale of 1 to 7). We asked 22 friends to taste each of the three wines (in a blind fold fashion), and then to give a grade of 1 till 7 (for example sake, let’s say we asked them to rate the wines 5 times each, and then averaged their results to give a number for a persons preference for each wine. This number which is now an average of several numbers, will not necessarily be an integer).

After getting the results, we started by performing a simple boxplot of the ratings each wine got. Here it is:

The plot shows us two things: 1) that the assumption of equal variances here might not hold. 2) That if we are to ignore the “within subjects” data that we have, we have no chance of finding any difference between the wines.

牵手常德棋牌官方下载So we move to using the function “friedman.test.with.post.hoc” on our data, and we get the following output:

$Friedman.Test

Asymptotic General Independence Test

data: Taste by

Wine (Wine A, Wine B, Wine C)

stratified by Taster

maxT = 3.2404, p-value = 0.003421

$PostHoc.Test

Wine B – Wine A 0.623935139

Wine C – Wine A 0.003325929

Wine C – Wine B 0.053772757

The conclusion is that once we take into account the within subject variable, we discover that there is a significant difference between our three wines (significant P value of about 0.0034). And the posthoc analysis shows us that the difference is due to the difference in tastes between Wine C and Wine A (P value 0.003). and maybe also with the difference between Wine C and Wine B (the P value is 0.053, which is just borderline significant).

牵手常德棋牌官方下载Plotting our analysis will also show us the direction of the results, and the connected answers of each of our friends answers:

(The R code for Barnard’s exact test is at the end of the article, and you could also just download it from here, or )

About Barnard’s exact test

About half a year ago, I was studying various statistical methods to employ on contingency tables. I came across a promising method for 2×2 contingency tables called “Barnard’s exact test“. Barnard’s test is a non-parametric alternative to which can be more powerful (for 2×2 tables) but is also more time-consuming to compute (References can be found in the on the subject).

牵手常德棋牌官方下载The test was first published by (1945) (). explain why Barnard’s test can be more powerful than Fisher’s under certain conditions:

When comparing Fisher’s and Barnard’s exact tests, the loss of power due to the greater discreteness of the Fisher statistic is somewhat offset by the requirement that Barnard’s exact test must maximize over all possible p-values, by choice of the nuisance parameter, π. For 2 × 2 tables the loss of power due to the discreteness dominates over the loss of power due to the maximization, resulting in greater power for Barnard’s exact test牵手常德棋牌官方下载. But as the number of rows and columns of the observed table increase, the maximizing factor will tend to dominate, and Fisher’s exact test will achieve greater power than Barnard’s.

About the R implementation of Barnard’s exact test

After finding about Barnard’s test I was sad to discover that (at the time) there had been no R implementation of it. But last week, I received a surprising e-mail with good news. The sender, Peter Calhoun, currently a graduate student at the University of Florida, had implemented the algorithm in R. Peter had found my posting on the R mailing list (from almost half a year ago) and was so kind as to share with me (and the rest of the R community) his R code for computing Barnard’s exact test. Here is some of what Peter wrote to me about his code:

On a side note, I believe there are more efficient codes than this one. For example, I’ve seen codes in Matlab that run faster and display nicer-looking graphs. However, this code will still provide accurate results and a plot that gives the p-value based on the nuisance parameter. I did not come up with the idea of this code, I simply translated Matlab code into R, occasionally using different methods to get the same result. The code was translated from:

Trujillo-Ortiz, A., R. Hernandez-Walls, A. Castro-Perez, L. Rodriguez-Cardozo. Probability Test. A MATLAB file. URL

My goal was to make this test accessible to everyone. Although there are many ways to run this test through Matlab, I hadn’t seen any code to implement this test in R. I hope it is useful for you, and if you have any questions or ways to improve this code, please contact me at [email protected]