2657 Productions News » Geekiness

Using the reshape package in R for pivot-table-like functionality

Ananda — Sun, 08 Aug 2010 14:56:49 +0000

A little more than a week ago, I wrote about creating pivot tables in Microsoft Excel and OpenOffice.org. I also mentioned that I would explain how to do similar calculations by using R. This post will explain how to achieve similar results in R by using the reshape package.

I had initially started experimenting with the reshape package several months ago when I was trying to figure out how to reshape data from wide to long formats. However, once I started experimenting with it, I realized I had misunderstood what the reshape package was designed to do. Now that I finally have a grasp of what can be done using the package, I thought I would share what I’ve found using a few examples.

Part 1: Contingency tables using built-in functions

There are a lot of different ways to tabulate data in R. In this post, I’ll start by demonstrating how to use table, xtabs, and ftable before making things more interesting and using the reshape package to flip data around.

We’ll start with R’s built-in functions. First, we’ll get some data into R. We’ll start with a basic table from Wikipedia that was used to demonstrate cross-tabulation. I’ve already gone and put the data in a CSV file that can be loaded using the code below.

> handedness = read.csv("http://news.mrdwab.com/handedness")
> table(handedness)
        Handedness
Gender   left-handed right-handed
  Female           1            5
  Male             2            4

Did you see how easy it was to tabulate frequencies of the data? Unfortunately, not all data is that easy to work with. Now, we’ll add a couple of columns to the data.

> set.seed(123)
> fav.col = sample(c("red", "green", "blue"), 12, replace = T)
> set.seed(123)
> fav.shape = sample(c("square", "triangle", "circle"), 12, replace = T)
> handedness.plus = cbind(handedness,fav.col,fav.shape)

We can use the table function again to see what our data look like. In the following line, we are using favorite color (fav.col) as our rows, Gender as our columns, and separate tables for left-handed and right-handed respondents.

> table(handedness.plus$fav.col, handedness.plus$Gender,
       handedness.plus$Handedness)
, ,  = left-handed

        Female Male
  blue       0    1
  green      1    1
  red        0    0

, ,  = right-handed

        Female Male
  blue       2    2
  green      2    1
  red        1    1

This is OK, but the code is somewhat cumbersome. The xtabs function will give you the same result, but with some simpler code. Notice that we don’t need to use the “$” notation in the following code since the last element in our command identifies the data.

> xtabs(~ fav.col + Gender + Handedness, handedness.plus)
, , Handedness = left-handed

       Gender
fav.col Female Male
  blue       0    1
  green      1    1
  red        0    0

, , Handedness = right-handed

       Gender
fav.col Female Male
  blue       2    2
  green      2    1
  red        1    1

The ftable (flat table) function is even more flexible. Instead of having two separate tables, for instance, you can have a single table with the same information. With the ftable function, you mention the data, and then identify what data you want to use for rows, and what data you want to use for your columns. In our data, we have four columns named “Gender“, “Handedness“, “fav.col“, and “fav.shape“. If we wanted a flat table version of the previous output, we want the third column as our rows, and our columns are determined by the first and third columns. Here are three examples and their output.

> ftable(handedness.plus, row.vars = 3, col.vars = c(1, 2))
        Gender          Female                     Male
        Handedness left-handed right-handed left-handed right-handed
fav.col
blue                         0            2           1            2
green                        1            2           1            1
red                          0            1           0            1
> ftable(handedness.plus, row.vars = 1, col.vars = c(2, 4))
       Handedness left-handed                 right-handed
       fav.shape       circle square triangle       circle square triangle
Gender
Female                      0      0        1            2      1        2
Male                        1      0        1            2      1        1
> ftable(handedness.plus, row.vars = 1:3, col.vars = 4)
                            fav.shape circle square triangle
Gender Handedness   fav.col
Female left-handed  blue                   0      0        0
                    green                  0      0        1
                    red                    0      0        0
       right-handed blue                   2      0        0
                    green                  0      0        2
                    red                    0      1        0
Male   left-handed  blue                   1      0        0
                    green                  0      0        1
                    red                    0      0        0
       right-handed blue                   2      0        0
                    green                  0      0        1
                    red                    0      1        0

Part 2: Advanced results using the reshape package

These flat frequency tables are informative, but they may not provide you all the information you actually want. For instance, what if you wanted more pivot-table-like results, where you were interested in not just frequencies, but maybe also sums and averages. If that’s the case, then you really need to figure out how to use the reshape package. Here are some examples.

First, we’ll load the package, load some data, and preview the rows in our data. (We’ll use the same data from the Pivot Tables in Excel and OpenOffice.org Calc post.)

> library(reshape)
Loading required package: plyr
Loading required package: plyr
> book.sales = read.csv("http://news.mrdwab.com/booksales")
> names(book.sales)
[1] "Representative" "Region"         "Month"          "Publisher"
[5] "Subject"        "Sales"          "Margin"         "Quantity"

In order to use the reshape package, you need to “melt” the data. The melting function asks for id variables (id.vars) and measured variables (measured). In the case of the book sales dataset, the measured variables are “Sales“, “Margin“, and “Quantity” (columns 6 through 8). Using that information, we melt the data using the following code.

> m.book.sales = melt(book.sales, id.vars = 1:5)

Now, it’s time to play around and see what we can do with reshape. The counterpart to “melt” is “cast“. We first mention what dataset we are working with (m.book.sales) and then the reshape function that we want to use. We use the “~” symbol to define relationships. The “~” is usually read as “is described by”, but it’s best understood with some experimentation.

> cast(m.book.sales, Region ~ variable)
Aggregation requires fun.aggregate: length used as default
  Region Sales Margin Quantity
1      E    15     15       15
2      N   122    122      122
3      S    91     91       91
4      W    77     77       77

Well, that’s not really useful. But the notice provided, “Aggregation requires fun.aggregate: length used as default” is helpful. What that means is that we need to tell R what functions we want to use, for instance, “sum” or “mean“. Let’s try this again.

> cast(m.book.sales, Region ~ variable, sum)
  Region   Sales  Margin Quantity
1      E  2267.0 1081.84      135
2      N 18328.3 8552.22     1130
3      S 13276.5 6230.62      813
4      W 12078.8 5758.08      690

Much better. But, can we make more complicated tables? Here’s one sorted first by region, then by representative.

> cast(m.book.sales, Region + Representative ~ variable, sum)
   Region Representative   Sales  Margin Quantity
1       E           Kunj 1309.00  606.37       82
2       E         Rajesh  958.00  475.47       53
3       N        Gajanan 5348.95 2551.27      307
4       N        Mallesh 6931.70 3273.15      445
5       N          Priya 4790.65 2168.95      309
6       N           Ravi 1257.00  558.85       69
7       S        Mahanta 3780.70 1698.01      239
8       S            Raj 3463.80 1690.53      183
9       S           Soni 6032.00 2842.08      391
10      W     Shreekanth 4065.20 1930.84      222
11      W      Shreerang 3570.20 1675.55      213
12      W      Sree Hari 4443.40 2151.69      255

Notice that the above code is a convenient flat table. Also, the above table works well because each representative only sells in one region. But what if we had used “Region + Representative” instead?

> cast(m.book.sales, Region + Publisher ~ variable, sum)
   Region   Publisher  Sales  Margin Quantity
1       E  Bloomsbury  261.0  137.03       18
2       E McGraw-Hill 1116.0  507.45       58
3       E   Routledge  120.0   64.80        6
4       E        SAGE  610.0  289.36       43
5       E        Viva  160.0   83.20       10
6       N  Bloomsbury 2812.5 1267.79      237
7       N McGraw-Hill 3901.8 1783.68      193
8       N     Penguin  864.0  403.56       54
9       N   Routledge 3741.0 1690.60      174
10      N        SAGE 5484.8 2629.49      380
11      N        Viva 1524.2  777.10       92
12      S  Bloomsbury 1335.0  595.01      114
13      S McGraw-Hill 2455.8 1123.62      125
14      S     Penguin  972.0  429.30       67
15      S   Routledge 2688.0 1292.60      123
16      S        SAGE 4640.6 2206.77      320
17      S        Viva 1185.1  583.32       64
18      W  Bloomsbury  787.5  371.21       63
19      W McGraw-Hill 4299.0 1944.25      203
20      W     Penguin  414.0  188.82       29
21      W   Routledge 1834.0  904.78       85
22      W        SAGE 3540.3 1733.46      246
23      W        Viva 1204.0  615.56       64

Notice that now things are not so tidy. Books from a given publisher are sold in multiple districts. By sticking another “~” into the code after “variable“, we can get some separated tables. Compare the following table with the previous one.

> cast(m.book.sales, Region ~ variable ~ Publisher, sum)
, , Publisher = Bloomsbury

      variable
Region  Sales  Margin Quantity
     E  261.0  137.03       18
     N 2812.5 1267.79      237
     S 1335.0  595.01      114
     W  787.5  371.21       63

, , Publisher = McGraw-Hill

      variable
Region  Sales  Margin Quantity
     E 1116.0  507.45       58
     N 3901.8 1783.68      193
     S 2455.8 1123.62      125
     W 4299.0 1944.25      203

, , Publisher = Penguin

      variable
Region Sales Margin Quantity
     E     0   0.00        0
     N   864 403.56       54
     S   972 429.30       67
     W   414 188.82       29

, , Publisher = Routledge

      variable
Region Sales  Margin Quantity
     E   120   64.80        6
     N  3741 1690.60      174
     S  2688 1292.60      123
     W  1834  904.78       85

, , Publisher = SAGE

      variable
Region  Sales  Margin Quantity
     E  610.0  289.36       43
     N 5484.8 2629.49      380
     S 4640.6 2206.77      320
     W 3540.3 1733.46      246

, , Publisher = Viva

      variable
Region  Sales Margin Quantity
     E  160.0  83.20       10
     N 1524.2 777.10       92
     S 1185.1 583.32       64
     W 1204.0 615.56       64

What if we wanted totals? To get that, we need to add “margins” to our code.

> cast(m.book.sales, Region ~ variable, sum, margins=c("grand_col", "grand_row"))
  Region   Sales   Margin Quantity    (all)
1      E  2267.0  1081.84      135  3483.84
2      N 18328.3  8552.22     1130 28010.52
3      S 13276.5  6230.62      813 20320.12
4      W 12078.8  5758.08      690 18526.88
5  (all) 45950.6 21622.76     2768 70341.36

And, what if we wanted both sum and mean? We can set up multiple functions as follows.

> cast(m.book.sales, Region ~ variable, c(sum, mean))
  Region Sales_sum Sales_mean Margin_sum Margin_mean Quantity_sum Quantity_mean
1      E    2267.0   151.1333    1081.84    72.12267          135      9.000000
2      N   18328.3   150.2320    8552.22    70.10016         1130      9.262295
3      S   13276.5   145.8956    6230.62    68.46835          813      8.934066
4      W   12078.8   156.8675    5758.08    74.78026          690      8.961039

Of course, we can also subset our data so that we just get information on selected variables. You may remember from the original book sales dataset that the “variables” are “Sales“, “Margin“, and “Quantity“. We can use that information to cast different summary tables. Here are two more examples.

> cast(m.book.sales, Region + Representative ~ variable,
      c(length, sum, mean), subset = variable %in% "Sales")
   Region Representative Sales_length Sales_sum Sales_mean
1       E           Kunj            8   1309.00   163.6250
2       E         Rajesh            7    958.00   136.8571
3       N        Gajanan           33   5348.95   162.0894
4       N        Mallesh           47   6931.70   147.4830
5       N          Priya           35   4790.65   136.8757
6       N           Ravi            7   1257.00   179.5714
7       S        Mahanta           24   3780.70   157.5292
8       S            Raj           23   3463.80   150.6000
9       S           Soni           44   6032.00   137.0909
10      W     Shreekanth           26   4065.20   156.3538
11      W      Shreerang           22   3570.20   162.2818
12      W      Sree Hari           29   4443.40   153.2207
> cast(m.book.sales, Region + Representative ~ variable,
      c(sum, mean), subset = variable %in% c("Sales", "Quantity"))
   Region Representative Sales_sum Sales_mean Quantity_sum Quantity_mean
1       E           Kunj   1309.00   163.6250           82     10.250000
2       E         Rajesh    958.00   136.8571           53      7.571429
3       N        Gajanan   5348.95   162.0894          307      9.303030
4       N        Mallesh   6931.70   147.4830          445      9.468085
5       N          Priya   4790.65   136.8757          309      8.828571
6       N           Ravi   1257.00   179.5714           69      9.857143
7       S        Mahanta   3780.70   157.5292          239      9.958333
8       S            Raj   3463.80   150.6000          183      7.956522
9       S           Soni   6032.00   137.0909          391      8.886364
10      W     Shreekanth   4065.20   156.3538          222      8.538462
11      W      Shreerang   3570.20   162.2818          213      9.681818
12      W      Sree Hari   4443.40   153.2207          255      8.793103

Who needs pivot tables in Excel?

Related posts (possibly):

Pivot Tables in Excel and OpenOffice.org Calc One of the features I find useful in Excel is...
Quickly reshaping data from “wide” to “long” formats in R A lot of the times, students at the Academy enter...
R is like a giant calculator for grownups One of the things that is interesting about R is...

Pivot Tables in Excel and OpenOffice.org Calc

Ananda — Thu, 29 Jul 2010 19:34:42 +0000

One of the features I find useful in Excel is the ability to create “pivot” tables. Essentially pivot tables let you summarize big tables of data in different ways, using different variables to “pivot” your data around (hence the name, I guess). Pivot tables are most easily understood through an example, so here’s one done using Excel 2007, and the sort-of-equivalent “Data-Pilot” in OpenOffice.org Calc (OO.o Calc).

Below is the data we’ll be working with. As you can see, it’s a long spreadsheet with eight columns (Representative, Region, Month, Publisher, Subject, Sales, Margin, and Quantity) and over 300 rows. Certain calculations, like total sum of sales, are easy–you just select the sales column and use Excel’s or OO.o Calc’s sum function. But what if you wanted total sum of sales, but organized first by region, then by representative? That’s where pivot tables come into play, so let’s get started!

Download the CSV file and open it up in Excel. Select all the data, jump over to the “insert” menu, and click on “PivotTable”. This will open a dialog box similar to the following.

Create PivotTable Dialog Box

I usually select the option to insert the pivot table in a new sheet, and this brings us to the following screen.

Empty PivotTable screen

Example panel selections

Pretty plain looking, right?

The important part is the “PivotTable Field List” menu to the right of the screen. In the top half, you have a list of the variables in your data. The bottom half is where the “pivoting” gets set up simply by dragging the variables into the relevant areas in the bottom. In this example, I started by dragging “Region” to be the primary way to summarize the rows, and I dragged “Representative” below that to indicate that the rows should be further sorted by the sales representatives, and finally I dragged “Sales”, “Margin”, and “Quantity” to the sum value box.

By default, Excel assumes you want the sum, but you can also do different data summaries by right-clicking on the variables that you’ve dragged to the “values” corner. Whatever you drag into the filters area will create additional filter options for your data.

Experiment a little bit–drag things around a bit and see what types of consolidated results you end up with. Whatever you change in the PivotTable Field List dialog area is immediately reflected in the main spreadsheet area (which is one huge advantage that Excel 2007 has over OO.o Calc).

By dragging some variables around, here’s what we can quickly end up with:

Example PivotTable Output

The process in OpenOffice.org Calc is pretty similar. The option can be found under the “Data” menu under “DataPilot”. The screencap below shows the DataPilot options window with some variables dragged into the relevant areas to create a simple pivot table in OO.o Calc.

OO.o Calc DataPilot with some options filled in

The “Page Fields” region in OO.o Calc is the equivalent of the filters area in Excel 2007. The rest is pretty much the same, just not as pretty. The output (in the screencap below) isn’t as pretty either, but it serves its function just fine.

OO.o Calc's less pretty but still functional output

So, now that you know all about pivot tables in Excel and OO.o Calc, you can have a data sorting and summarizing party. Once you get bored with that, you can sit around impatiently and wait for me to write about how you can do this sort of thing with R.

Related posts (possibly):

Using the reshape package in R for pivot-table-like functionality A little more than a week ago, I wrote about...
Drop caps with OpenOffice.org Writer Tutorial Level: Elementary From time to time, I like some...
Automation with OpenOffice.org Writer Tutorial Level: Intermediate At the Tata-Dhan Academy where I work,...

Getting data into R

Ananda — Sun, 11 Jul 2010 15:53:15 +0000

When you first open R, you’re greeted with a screen similar to the following:

R version 2.10.0 (2009-10-26)
Copyright (C) 2009 The R Foundation for Statistical Computing
ISBN 3-900051-07-0

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

  Natural language support but running in an English locale

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

>

I’ve been trying to encourage my students to use R for some of their work, but in the process, I sort of forgot that for most people, starting up a program and just being greeted with a command prompt might be somewhat intimidating. So after several of my students indicated that they had downloaded and installed R but had no idea what to do next, I thought I would write about some of the very basic ways to get started. I recognize that for some huge datasets, the suggestions here are not the best, but for me, and for most of my students, the datasets that we would be working with are actually quite small.

Part one: Entering your data directly in R

For really small sets of data or for quick calculations, you might just go ahead and enter your data directly in R. The easiest way to do this is to start by entering each set of data as objects. In the following example, we’re going to create a data frame (a table in R) with the names of some of my students and the scores they’ve received on three assignments in a fictional course titled “Data Analysis with R for NGO Workers”.

> Student = c("Gajanan", "Hari", "Priya", "Raj", "Shreekanth", "Shreerang",
+ "Soni", "Vinay")
> Assignment.1 = c(93, 98, 90, 70, 80, 82, 75, 77)
> Assignment.2 = c(90, 87, 83, 88, 78, 87, 79, 84)
> Assignment.3 = c(97, 92, 85, 90, 77, 70, 90, 93)

Notice that by entering this information, you don’t receive any “acknowledgement” from R than anything has happened. It just shows you the prompt again. To see the entry, you would need to then type the name of the object that you have created, for instance, “Student”, “Assignment.1″, “Assignment.2″, or “Assignment.3″ in order to see the values. Notice also that R is case-sensitive. So, typing “student” would result in an error since we had entered the name with an upper-case “S”. Notice also that if you have not completed your statement (as in the first object we were creating) R adds a little “+” at the start of the line to indicate to you that your statement is incomplete.

Here’s what we get when we type “Assignment.2″

> Assignment.2
[1] 90 87 83 88 78 87 79 84

The “[1]” at the start of the second line above is the index of the first value. Consider the following:

> set.seed(123); sample(300, 30)
 [1]  87 236 122 263 279  14 156 262 162 133 278 132 196 165  30 257  70  12  93
[20] 269 250 194 179 276 181 195 150 163  79  40

In this case, the number “269″ is the twentieth number in this list of numbers. (See Simple sampling with R and Sampling with replacement in R for a basic introduction to sampling.) Knowing the index of a number can be useful when you need to know the position of a certain value since occasionally, you want to select just a single value from a vector. Type the following and compare it to what you got when you typed “Assignment.2″:

> Assignment.2[3]
[1] 83

R has returned the third value from the object you created.

If you want to create a simple table of these four sets of data you’ve created, you use the “data.frame” function. The first line below creates a data frame called “R.For.NGOs” and the second one tells R to display it. The third line opens up R’s built-in spreadsheet, which I generally don’t use except to quickly scan data.

> R.For.NGOs = data.frame(Student, Assignment.1, Assignment.2, Assignment.3)
> R.For.NGOs
     Student Assignment.1 Assignment.2 Assignment.3
1    Gajanan           93           90           97
2       Hari           98           87           92
3      Priya           90           83           85
4        Raj           70           88           90
5 Shreekanth           80           78           77
6  Shreerang           82           87           70
7       Soni           75           79           90
8      Vinay           77           84           93
> fix(R.For.NGOs)

Now, try using the index feature and see what happens.

> R.For.NGOs[3]
  Assignment.2
1           90
2           87
3           83
4           88
5           78
6           87
7           79
8           84

This is probably not what you expected, right? R has returned just the third column. Once data is in a table or a matrix, R needs both a column and a row index to return a specific value. Let’s say we wanted Gajanan’s score for the third assignment. For this, Assignment 3 is the fourth column, and Gajanan is the first row, so we need to reference the index “[1,4]“. If we wanted only Priya’s scores, she’s the third row, so we would need to reference the index “[,3]“. (Note that you do not write “[0,3]“.)

> R.For.NGOs[1,4]
[1] 97
> R.For.NGOs[,3]
[1] 90 87 83 88 78 87 79 84

Part 2: Using a spreadsheet for data entry

As you can see above, it is not too difficult to create your data right in R. However, if you had a dataset that has a lot of records (like the one I used in Quickly reshaping data from ), you would be silly to use R. For such data, it makes much more sense to use something like OpenOffice.org Calc or Microsoft Excel or some other spreadsheet interface. For starters, you would be more comfortable with the interface. Additionally, there may be more opportunities to quickly check your data over for errors, and you might even be able to set up data-entry rules to prevent incorrect values from being entered.

How do you get your data into R if it’s in an Excel file or another spreadsheet? There are several ways. The most common one I use is to just save my data as a comma separated value (CSV) file and open that in R. The second most common approach I use is to copy the data and use R’s “clipboard” feature to get the data into R. Here’s how you’d proceed for each of these approaches. I’ll assume that you’ve used “File > Change dir…” to have R working out of your “My Documents” folder and that your CSV file is saved in that folder. Here, I’m going to create an object in R called “Book.Sales” using a file called “BookSales.csv” stored in my “My Documents” folder. This file has the data starting on the second row; the first row contains the column names.

> Book.Sales = read.csv("BookSales.csv", header=T)

If you don’t want to change the working directory, you can also enter the full path to the file. For example “c:\\data\\file.csv” or “c:/data/file.csv” can be used to access a file called “file.csv” in a folder named “data” on drive C. Also, if you know the URL of a CSV file, you can access the file directly by typing the URL in place of the file name. This is the option I usually use for my online examples.

Some advice: do not use spreadsheets with merged cells and lots of blank cells at the top. Instead, create a new CSV file where the first row contains the column names and the data starts on the next line. That makes putting your data into R very easy….

If you prefer to go the “cut-and-paste” way, just open up your spreadsheet, copy the cells you’re interested in, and type the following (we’ll assume it is the same dataset):

> Book.Sales = read.delim("clipboard", header=T)

The main difference between the read.table and read.csv options is that the CSV option looks for a comma separating each value, while the read.delim looks for a tab character.

Once you’ve overcome the hurdle of getting data into R, playing with your data will be much more fun!

Related posts (possibly):

Quickly reshaping data from “wide” to “long” formats in R A lot of the times, students at the Academy enter...
A little spark for presenting your data For some reason, I’ve been obsessing over the presentation of...
Am I inconsistent? I won’t pretend that I don’t have any illegal software...

The awesomeness that is WordPress and child themes

Ananda — Thu, 08 Jul 2010 16:10:46 +0000

After a long long long time, I decided to get back into some actual website experimentation. For a while, I was really lazy with my site design and settled on using the Atahualpa theme. This was a great be-lazy theme, but I noticed that while browsing other sites, it often became too obvious which sites were made using the theme and me, always wanting “my own thing” decided that it was time to get my hands at least a little bit dirty again.

I had posted a little while ago about my excitement and my disappointment over the Google Font Directory and that had inspired me to look into other ways to get some custom fonts online. Font Squirrel offered a great free @font-face generator, so I loaded up my Mr. Grumpy fonts and decided to see what I could do with it.

With my fonts ready, I decided to get back into my own theme design. This time, rather than designing the theme from scratch, I decided to create a child theme for one of the better theme frameworks I found: Thematic.

For those of you who don’t know what a child theme is, think about it this way. WordPress periodically needs to be updated (to fix bugs, add new features, enhance security, and so on). When you host your own WordPress installation, you’re also tempted (at least nerdy people like me are tempted) to customize the themes they use, and in the past, that often meant making edits to the original theme files. But just as WordPress needs to be periodically updated, so to does its themes (for example, when WordPress added widget support or post thumbnail support, theme modifications were required). When you updated your theme, however, all of your customizations would them be lost.

Child themes solve this problem by letting you use a well-structured theme that is up-to-date with all the WordPress features you need, creating a new folder in your WordPress themes directory for your child theme, and creating a new theme by doing as little as creating a new stylesheet that imports the styles from your chosen template. If you need to make more significant changes to the parent theme, instead of modifying the actual theme files, you create a “functions.php” file in your child theme directory. So, for instance, if you’ve decided that you don’t want the “access” div that’s present in the Thematic framework, you can remove it by adding the following to your functions.php file:

// Remove Thematic access
function remove_access() {
remove_action('thematic_header','thematic_access',9);
}
add_action('init','remove_access');

Or, if you want to add something to the head of your page (like some extra javascript or something) you can add something like the following:

function yourfunctionname() { ?>


In the above snippet, the first line starts with naming our function, and ends with { ?> which switches us out of PHP so we can add normal HTML. The last line is where we make the call to the function that we just defined. There are some good instructions at the Thematic Theme Framework Guide for how to use the different Thematic hooks and filters to create a truly customized site. 
As I was making these changes, A List Apart published a great article about full-screen backgrounds and, of course, I had to try it out. But, I wanted to take it a little bit further: make the background change with each page. So, for that, I used Matt’s random image script and put that into my stylesheet. This is something I might change though. It seems like referencing the PHP file in the CSS works as I expected with Opera and Firefox (a different background image for each page) but with Chrome, it loads a different backround image only once each session (which is also OK, but not what I was looking for). (From A List Apart, I also borrowed ideas for using CSS transparency and rounded corners, as well as their ideas for applying different CSS rules for different window sizes.) 
Here are a few snippets of the CSS customization.
For the transparency and rounded corners for the header area and the main text area:
#branding
{
	margin-top: 20px;
}
#main, #branding
{
	background-color: #F8F8F8;
	border-radius: 12px;
	margin-bottom: 20px;
	-moz-border-radius: 12px;
	-webkit-border-radius: 12px;
	filter: alpha(opacity=90);
	-khtml-opacity: 0.9;
	-moz-opacity: 0.9;
	opacity: 0.9;
}

For centering the page if the screen is small and floating the content to the right if the page is wider than 1280 pixels:
@media all and (min-width: 1280px)
{
	#branding, #main
	{
		float: right;
		margin-right: 20px;
	}
}
@media only all and (max-width: 1024px) and (max-height: 768px)
{
	body
	{
		background-size: 1024px 768px;
		-moz-background-size: 1024px 768px;
	}
}

For getting a random image each time the page is rotated. Instead of mentioning an image URL like you normally would, you instead mention the rotate image script I referenced earlier.
body
{
	background: #fff url(rotatebg.php) left bottom fixed no-repeat;
	background-size: cover;
	color: #000;
	margin: 0;
	-moz-background-size: cover;
	padding: 0;
}

Maybe eventually, when I get around to tweaking this a bit more and testing it in some other browsers (I’m not even going to bother being nice to Internet Explorer) I’ll package up the child theme and share it….


Related posts (possibly):
2657 Productions is going to get a facelift I’ve been trying to keep myself busy recently. As I...
Nested Lists and CSS I don’t use lists too often for my own stuff,...
DAMN It! I was just having some fun at work a couple...

R is like a giant calculator for grownups

Ananda — Wed, 30 Jun 2010 07:04:28 +0000

One of the things that is interesting about R is how flexible it is. One of the fun things about it is how interactive it can be. While my examples so far have been a little bit more involved, it can be useful to spend some time just getting acquainted with how R performs basic calculations. In fact, I sometimes like to think of R as a giant calculator for grownups to play with. The following syntax snippets show how you can perform basic calculations with R. This is by no means complete, but it should provide a reasonable introduction to someone just getting started with R. (Experienced R users would find this TOTALLY useless….)

Let’s get started with really basic stuff…. (By the way, everything in the syntax following the “#” is treated as a comment and is not processed by R. They are just there to explain what’s going on at each step for the uninitiated….)

> 2+2 # addition
[1] 4
> 2-2 # subtraction
[1] 0
> 2*3 # multiplication
[1] 6
> 2/2 # division
[1] 1
> 2^3 # exponents
[1] 8
> sqrt(16)/2 # square root
[1] 2
> 16^(1/2) # square root (as exponent)
[1] 4
> 8^(1/3) # cubed root (you get the idea)
[1] 2

Creating objects in R can make it convenient to perform calculations.

> aa = 8^(1/3) # assigning a variable with the name "aa"
> aa^2 # aa squared
[1] 4
> (8^(1/3))^2 # same as "aa^2" above
[1] 4
> bb = c(1,2,3,4,5) # an object with the numbers 1 to 5, named "bb"
> cc = 10 # a single object with the value "10"
> bb/cc # doing basic math on the objects
[1] 0.1 0.2 0.3 0.4 0.5
> bb+cc # more basic math
[1] 11 12 13 14 15
> dd = c(25:21) # another way to create a series of numbers (descending)
> dd-bb # subtracts 1 from 25, 2 from 24, and so on
[1] 24 22 20 18 16
> sum(dd-bb) # "sum" of the resulting values of the expression "dd-bb"
[1] 100
> mean(dd-bb) # average of the resulting values of the expression "dd-bb"
[1] 20
> ddd = dd-bb # you can even create *another* object....
> mean(ddd) # you get the idea...
[1] 20
> summary(ddd) # convenient summary statistics about a distribution
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.
     16      18      20      20      22      24

You can even set up your own equations as “functions” in R.

> area.circ = function(r) {pi*r^2} # solving simple equations
> area.circ(1) # calculating for a radius of 1...
[1] 3.141593
> area.circ(2) # ... and a radius of 2
[1] 12.56637
> y = function(m,x,b) (m*x+b) # more simple equations... set up the function
> y(12,2,2) # and feed R the values that you want to use
[1] 26

A table (a data frame, really) is an example of an object in R. Below, we create two tables, each with 5 rows and 3 columns. Then, we perform some basic calculations on the tables.

> var.1 = c(1:5) # create a vector with the numbers 1 to 5
> set.seed(123) # set a seed so you can replicate this
> var.2 = c(sample(300,5)) # randomly sample 5 numbers from 300
> set.seed(123) # ...
> var.3 = c(sample(500,5)) # randomly sample 5 numbers from 500
> var.1 + var.2 + var.3 # do some basic mathematics
[1] 232 632 329 706 751
> table.1 = data.frame(var.1, var.2, var.3) # put your objects into a table
> table.1 # view your table
  var.1 var.2 var.3
1     1    87   144
2     2   236   394
3     3   122   204
4     4   263   439
5     5   279   467
> table.1+10 # add 10 to every item in your table
  var.1 var.2 var.3
1    11    97   154
2    12   246   404
3    13   132   214
4    14   273   449
5    15   289   477
> table.1*var.1 # multiply your table by var.1
  var.1 var.2 var.3
1     1    87   144
2     4   472   788
3     9   366   612
4    16  1052  1756
5    25  1395  2335
> # notice that R goes from top to bottom and loops.
> table.1*c(1:3) # Try the same thing with multiplying by c(1:3))
  var.1 var.2 var.3
1     1   261   288
2     4   236  1182
3     9   244   204
4     4   789   878
5    10   279  1401
> var.4 = c(6:10) # set up some new variables
> set.seed(123)
> var.5 = c(sample(100,5))
> set.seed(123)
> var.6 = c(sample(200,5))
> table.2 = data.frame(var.4, var.5, var.6) # and create a second table
> table.2 # view your table
  var.4 var.5 var.6
1     6    29    58
2     7    79   157
3     8    41    81
4     9    86   174
5    10    91   185
> table.1+table.2 # add table.1 and table.2 together
  var.1 var.2 var.3
1     7   116   202
2     9   315   551
3    11   163   285
4    13   349   613
5    15   370   652
> table.1*table.2 # multiply table.1 and table.2 together
  var.1 var.2 var.3
1     6  2523  8352
2    14 18644 61858
3    24  5002 16524
4    36 22618 76386
5    50 25389 86395

Creating a matrix by multiplying vectors is also very easy.

> aa = var.1 %o% var.4; # create a matrix multiplying var.1 by var.4
> row.names(aa) = var.1; colnames(aa) = var.4 # set your row and column names
> aa # view your output. It's a nice multiplication table!
   6  7  8  9 10
1  6  7  8  9 10
2 12 14 16 18 20
3 18 21 24 27 30
4 24 28 32 36 40
5 30 35 40 45 50

Related posts (possibly):

Getting data into R When you first open R, you’re greeted with a screen...
Simple sampling with R I mentioned in an earlier post (Am I inconsistent?) that...
Sampling with replacement in R In my last post about sampling (Simple sampling with R)...

A little spark for presenting your data

Ananda — Thu, 17 Jun 2010 16:18:16 +0000

For some reason, I’ve been obsessing over the presentation of data. (Either it is that I’ve just read all of Edward Tufte‘s books, or I’m just being a nerd. But I guess that those two things aren’t exactly exclusive….) Considering my obsession, you could imagine how I felt when one of my students stood up and made a presentation that included the following slides, along with the typical, “As you can see here, the production of rice has been decreasing. And as you can see in this chart, the production of wheat has been decreasing,” for slide after slide after slide.

If for some reason you’re not able to see the embedded slides, you can also view the slides in a new window.

For me, there are several problems with this. First, I can’t really compare the first slide with, say, the eight, because I’m not given enough time to do so. Second, if the main point is to just talk about “increasing” and “decreasing”, are this many slides necessary? Third, the axes on the charts aren’t the same, making comparisons more difficult. Oh, and printing out all of your slides as a handout doesn’t help either.

For something like this, sparklines–one of the many interesting ideas that Tufte suggests–might be a solution, and they fit in well with my advice to my students that they should prepare presentation “fact sheets” or something similar rather than prepare slide after slide in PowerPoint. So, I thought I should figure out what my options are for creating them (short of downloading an illegal copy of Microsoft Office 2010, which is supposed to have sparklines built into the charting options).

It turns out that there are several options for making sparklines, whether you are using OpenOffice.org or Microsoft Office, or, for that matter, preparing data for presentation online. And, since it’s pretty easy to figure out the offline options, I thought I would try out the Google Chart application programming interface (API) to see what I could do with it.

The construct is pretty basic. You have some code that looks like “data.addColumn(“number”, “Revenue”);” representing all of your “columns” of data and the data for each column is represented in an array like “data.setValue(0,0,435);” where the first number is the position on the x-axis for the item you’re charting, the second number is the variable you’re charting (since you might have several), and the third number is the value of the variable at that position.

Here’s the problem, though. The format that my data is in looks like this:

To present my data using the Google Chart API would require a lot of annoying cutting and pasting.

Or would it?

Of course we could just make our lives easier by using R to prepare our data, and here’s how.

First, load the data (using “read.csv” and creating a data frame), create a new object in R with the column names (we’re lazy, right, and we don’t want to type any more than we have to). Also, convert the data frame that you created into a matrix, and convert the values to numeric values. If this sounds complicated, it’s not. It’s just the following few lines of code:

> crop.prod = read.csv("http://news.mrdwab.com/cropproduction",
+                      header = T, row.names = 1)
> crop.prod.names = names(crop.prod) # object with the column names
> crop.prod.num = c(as.numeric(as.matrix(crop.prod))) # data values

Next, we want to set things up so that we can “paste” our data together in a form that the Google Chart API can process.

> prefix.column = "data.addColumn(\"number\", \"" # ugly, I know
> prefix.value = "data.setValue(" # but we'll clean it up later
> end.column = "\");" # to be pasted at the end of each line of column names
> end.value = ");" # to be pasted at the end of each line of data

R has this great function where you can paste things together. Well use that function to get our data in a nicer format. We’ll still have to clean it up a little bit (mostly removing extra commas and quotation marks) but that’s a simple search-and-replace procedure.

> # pasting together the column names
> column.names = paste(prefix.column,crop.prod.names,end.column)
> # pasting together each measurement of data
> crop.prod.data = paste(c(0:10),sort(rep(c(0:7),11)),crop.prod.num, sep=",")
> crop.prod.data = paste(prefix.value,crop.prod.data,end.value)

The most complicated line above is the crop.prod.data = paste(c(0:10),sort(rep(c(0:7),11)),crop.prod.num, sep=",") line, but even that is not too difficult to follow. “crop.prod.data” is the name of our object. That object comprises three values, each separated by a comma. The first value is the digits 0 to 10, (eleven values overall) looped for as long as required. The second value is eleven 0s, eleven 1s, eleven 2s and so on. The third value is the array from the “crop.prod.num” object we had created earlier.

At this point, we’re pretty much done. We just need to clean things up, and replace the contents of Google’s example page with our own data. Using fix(column.names) and fix(crop.prod.data) gives us the following output:

# output from "fix(column.names)"
c("data.addColumn(\"number\", \" Rice \");", "data.addColumn(
  \"number\", \" Wheat \");", "data.addColumn(\"number\", \" Pulses \")
  ;", "data.addColumn(\"number\", \" Cereals \");", "data.addColumn(
  \"number\", \" Food.Grains \");", "data.addColumn(\"number\", \" Oil.
  Seeds \");", "data.addColumn(\"number\", \" Cotton \");", "data.
  addColumn(\"number\", \" Sugarcane \");" )

# extracted output from "fix(crop.prod.data)" 
c("data.setValue( 0,0,4500 );", "data.setValue( 1,0,5000 );", "data.
  setValue( 2,0,6500 );", "data.setValue( 3,0,1000 );", "data.setValue(
  4,0,1750 );", "data.setValue( 5,0,1000 );", "data.setValue( 6,0,1750 
  );", ... ... ... "data.setValue( 2,1,8600 );", ... ... ...

Using any decent text editor (like Notepad++ or Komodo Edit [which I use]) makes getting rid of your unnecessary slashes and quotation marks a two second job, and then you are ready to do one last bit of copying and pasting, using the html on this page as a guide. Here’s what my final html looked like:

The output (seen below) can easily be copied into a MS Word document and more information can be added to it as necessary.

By the way, here is a PDF of a document created in OpenOffice.org demonstrating what this might look like in a table (made using the EuroOffice sparkline plugin) as well as what a stacked line graph would look like. Both of these would make much better handouts during a presentation than the printout of slides shown earlier.

Related posts (possibly):

Getting data into R When you first open R, you’re greeted with a screen...
Quickly reshaping data from “wide” to “long” formats in R A lot of the times, students at the Academy enter...
It’s a choropleth party with R, and everyone’s invited Map party time. For some reason this happens every once...

Font experiments, Part 2

Ananda — Thu, 20 May 2010 11:25:57 +0000

My initial excitement about the Google Font Directory is a little bit diminished right now.

According to the Google Code Blog:

The Google Font API hides a lot of complexity behind the scenes. Google’s serving infrastructure takes care of converting the font into a format compatible with any modern browser (including Internet Explorer 6 and up), sends just the styles and weights you select, and the font files and CSS are tuned and optimized for web serving.

But here are a few screencaps of my site in different browsers:

I guess this has inspired me to explore using the @font-face option though, so there might be some more font experiments on the way.

Related posts (possibly):

Font experiments Google just launched the Google Font Directory (beta, of course)...

Font experiments

Ananda — Thu, 20 May 2010 05:55:57 +0000

Google just launched the Google Font Directory (beta, of course) and the Google Font API which provides web-designers with an easy way to extend the font options that tend to limit many websites. Using the service is pretty simple: go to the font directory, find the font you want to use, and follow the simple instructions under the “Get the code” tab.

The font list seems a bit limited at the moment, but to experiment with the feature, I’ve changed all of the post headings at this site to be displayed in IM Fell English SC and the body text to Molengo. It would be great to see fonts like Gentium and Linux Libertine on there too.

Related posts (possibly):

Font experiments, Part 2 My initial excitement about the Google Font Directory is a...

It’s a choropleth party with R, and everyone’s invited

Ananda — Sun, 16 May 2010 17:10:00 +0000

Map party time. For some reason this happens every once in a while with me. A few years ago, I got to develop a website filled with choropleth maps galore. It was a pretty tedious process. Excel sheets. Photoshop. No good access to free Indian shapefiles. I was even thinking of making my own SVG files of Indian states at one point and thinking of a complex PHP and MySQL website.

Skip forward a few years now, and I’m back with the maps. Only this time, I have some new tools and resources: the software named after a pirate’s favorite letter, some free maps from the Global Administrative Areas website, some data from the 2001 Indian Census (I selected district data, all districts, and total population), and Google Docs (to clean up my CSV files).

Enough history. Let’s get started mapping, and since I’m in Tamil Nadu, I’m going to restrict myself to that state.

First, download the district level RData file from the GADM website (it’s a little under 7MB). Double-click on the file to open the R workspace. By using > ls() we can see that the only object in this workspace is named “gadm”. At this point, you can’t actually do much. Typing > fix(gadm) just pops up an editor window that says
<S4 object of class structure("SpatialPolygonsDataFrame", package = "sp")> which isn’t really useful. We need to load the libraries we’ll need:


> library(sp)
> library(RColorBrewer)

Since I want to see what is in the gadm object, I can just write a CSV of the object by typing > write.csv(gadm, "gadm-data.csv"). This will get us the following file:

As you can see, this spreadsheet is for all the districts in India, but I’m only interested in Tamil Nadu. Furthermore, without first sorting, not all of the Tamil Nadu districts are presented together. To fix this, I can simply create a new object for Tamil Nadu. For this, I only want the rows where the value in the “NAME_1″ column is “Tamil Nadu”. It might also be easier for me if I have a CSV of this new object so that I can arrange my data from the census in the right order, and it’s also easier if the district names (which are under the variable “NAME_2″) are in alphabetical order.


> Tamil.Nadu = gadm[gadm$NAME_1=="Tamil Nadu",] # Select only Tamil Nadu
> Tamil.Nadu = Tamil.Nadu[order(Tamil.Nadu$NAME_2),] # Order by district
> write.csv(Tamil.Nadu, "TN_db_raw.csv") # Write output as CSV

Fortunately, the names for the districts in the GADM dataset mostly match with those from the Indian census, so matching the data is quite straightforward. I’ve gone ahead and uploaded the combined information to Google Docs.

Let’s load this new file.


> TN.DB = read.csv("http://news.mrdwab.com/tnpop", header=T)
> names(TN.DB) # check to get variable names
[1] "NAME_2"     "Total_HH"   "Total_Pop"  "Male_Pop"   "Female_Pop"
[6] "Sex_Ratio"  "Area"       "Pop_Dens"

And now, let’s create a map. While it might be tempting to create a map of, say, total population, that’s not really how choropleth maps should be used. From the data here, without doing any further calculations, the only variable that makes sense to map is population density. I’ll start by doing a quick summary and plot to see what the data look like


# Use "digits=" to make sure that R doesn't round our results
> summary(TN.DB$Pop_Dens, digits=6)
     Min.   1st Qu.    Median      Mean   3rd Qu.      Max.
  278.870   343.480   416.850  1291.610   605.765 24963.500
> plot(TN.DB$Pop_Dens)

Notice the outlier. This will definitely affect our data if we don't deal with it.

From our plot, I can see that there is an outlier in the data. This is useful to know since if I simply went ahead and created our “bins” with that data point included, I wouldn’t end up capturing the variance between the lower values: they would most likely all be put into one bin.

In this map, I’m going to be lazy and simply divide the population density range into bins that are (more-or-less) equal sizes. You can also use quartiles if you prefer.


# Set your lower and upper limits, excluding the outlier, and length 
# equal to one more than the number of bins you actually want.
> TNPopDense = c(round(seq(from=0, to=1100, length=8), digits=0),
+              round(max(TN.DB$Pop_Dens)))
> TNPopDense # Preview our breaks
[1]     0   157   314   471   629   786   943  1100 24964
# Use our breaks to put each of the values in the "Pop_Dens" column
# into its corresponding bin.
> PopDenseRange = as.factor(as.numeric(cut(TN.DB$Pop_Dens, TNPopDense)))
> PopDenseRange # Preview which bins the districts fall into.
 [1] 3 8 4 4 2 3 3 5 7 3 5 4 3 3 2 2 2 4 2 5 3 5 4 3 4 3 3 4 3 3
Levels: 2 3 4 5 7 8

Note that this may not have been the best way to do this–I wanted to put each district in one of eight levels, preferably using all levels, but they only fall into six levels with this particular set of data.

Now, using the levels that we got in the previous step, we can work on our “legend” for the map. We can use “> 157″, “157 – 314″, and so on as our legend entries. After that, we merge a column into our TN.DB object to store these new values.


> levels(PopDenseRange) = list("< 157"="1", "157 - 314"="2", "315 - 471"="3",
+                         "472 - 629"="4", "630 - 786"="5", "787 - 943"="6",
+                         "943 - 1,100"="7", "> 1,100"="8")
> TN.DB$PopDenseRange = PopDenseRange # Merging info
> shadePopDense = brewer.pal(8, "Blues") # Setting up the coloring scheme
> Tamil.Nadu$PopDenseRange = PopDenseRange
# And now we plot it!
> PopDensePlot = spplot(Tamil.Nadu, "PopDenseRange", col="blue",
 +               col.regions=shadePopDense,
 +               main="Tamil Nadu population density by district")
> PopDensePlot

Here's our final map of population density.

And that’s pretty much it! I’m sure there’s a lot of room for improvement in the code and the process, but overall, not too bad for just a few lines of syntax in R. [R also exports really nice PDF files.]

Aside from referring to the typical R documentation, this example really helped me to figure out what I needed to do.

Related posts (possibly):

Getting data into R When you first open R, you’re greeted with a screen...
A little spark for presenting your data For some reason, I’ve been obsessing over the presentation of...
Quickly reshaping data from “wide” to “long” formats in R A lot of the times, students at the Academy enter...

Quickly reshaping data from “wide” to “long” formats in R

Ananda — Sun, 18 Apr 2010 08:57:45 +0000

A lot of the times, students at the Academy enter data in a “wide” format (since it is a very natural way to enter data in a spreadsheet). Let’s say, for example, that they were collecting data for a household, and for each person, they were collecting information on three variables. Assume also that they were only collecting information about five household members. They might end up with a first row of column names something like “HouseholdID” | “member.01″ | “member.02″ | “member.03″ | “member.04″ | “member.05″ | “variable1.01″ | “variable1.02″ | “variable1.03″ | “variable1.04″ | “variable1.05″ | “variable2.01″ | “variable2.02″ … and so on. Sometimes, however, we may find it more useful to have our data in a “long” format. This post tells you how to quickly do that using R.

Here’s an example spreadsheet with some nonsense data entered.

The data is fine in this format, but it makes it difficult to, say, look at everyone who, for ItemC, has “red” as their choice. Below is an example of the same data in the spreadsheet above in long format, from which we can easily determine the answer to such a question.

Now, you can get to those results with some painstaking cut-and-paste work, or you can do the smart thing and load your data into R and be done with your work in just a few lines of code. Here’s how.

Your first step is to get the data into R. How you do this depends on the current format of your data. This example uses a comma separated value (CSV) file stored using Google Spreadsheets. You can use the same URL, or you can use a locally stored file. (I’ve shortened the URL with a cool WordPress plugin called Pretty Link.) I’ll call the data frame “aa”. Since I know that the CSV file has a header row, I’ll add that argument in for R so that it will add column names automatically.


> aa = read.csv("http://news.mrdwab.com/reshape", header=T)

At this point, if you want to see what you’ve imported, you can use the "fix" function which will open up R’s data browser. I’m only interested in seeing the column names and seeing how many columns there are so instead, I’ve just used "names(aa)" which, as you can see below, lets me know that there are 21 columns in this data frame.


> names(aa)
 [1] "Unique.var" "UnitID.01"  "UnitID.02"  "UnitID.03"  "UnitID.04"
 [6] "UnitID.05"  "ItemA.01"   "ItemA.02"   "ItemA.03"   "ItemA.04"
[11] "ItemA.05"   "ItemB.01"   "ItemB.02"   "ItemB.03"   "ItemB.04"
[16] "ItemB.05"   "ItemC.01"   "ItemC.02"   "ItemC.03"   "ItemC.04"
[21] "ItemC.05"

The following is where the reshaping happens. We need to tell R what data is being reshaped (in this example, "aa"), which direction we want ("wide" or "long"), and which columns "vary" (in this example, columns 2 through 21; this is where the "names" command comes in useful. As we can easily see in the step above, there are 21 columns in this data frame.


> bb = reshape(aa, direction="long", varying=2:21)

Note: The code presented above is the simplest form of using the “reshape” command in R. Depending on how you have named the variables in your actual dataset, you might need to add a few arguments. For example, R will automatically use the period as a separator, but if your variables are named “variableA_01″, “variableA_02″ and so on, you will need to specify this information to R by adding sep="_" to the reshape command.

At this point, you can use a simple “fix” command to see what your data frame looks like.


> fix(bb) # "bb" is the name of the data frame we want to see, right?

It should look like this:

This is OK, but not great. First, you can see that R has sorted the data frame in a somewhat strange way. For example, I cannot see all of the information about Unique.var “1″ together since the first set of records is on the first row of the data (omitting the header), and the second set of records is on the twentieth row of data. There are also a lot of cells with NA values which, if removed, would make the dataset easier to view.


> cc = bb[with(bb, order(Unique.var)),] # Order the data frame by "Unique.var"
> dd = na.omit(cc) # Get rid of the NA cells.

After running those two lines, you’ll have almost what we had in the second spreadsheet in this post. From there, it’s just a matter of saving your final data frame as a CSV file, opening that in a spreadsheet program (I just use Google Docs), and delete the columns you don’t need (in this example, the first [unnamed] column, “time”, and “id”). Of course, when you are doing this, you don’t need to assign a new name to your data frames at each step. I only do it so that I can easily compare what is going on from change to change.

Related posts (possibly):

Getting data into R When you first open R, you’re greeted with a screen...
A little spark for presenting your data For some reason, I’ve been obsessing over the presentation of...
Using the reshape package in R for pivot-table-like functionality A little more than a week ago, I wrote about...