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):

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

Like this advertisement from a big electronics store:

Read the fine print...

So, I showed this ad to all of my Indian colleagues and my students, and none of them were able to see any problems. Even after I asked them what the definition of free is.

“It must be a very good deal,” everyone kept telling me, justifying the fine print. Apparently, in India, free means “a 30% discount”; in the same ad that was announcing “Pay Rs. 2000 extra and get a DVD Writer FREE”, Croma was advertising DVD writers for Rs. 2900.

But that’s not the only great “FREE” that I’ve seen. Earlier this week, I went to Nagapattinam with the PDM 9 students to see what community radio is all about. At the end of the trip, we stopped at Velakanni to see the town’s big church and check out the ocean.

Here’s the first sight that we were greeted with:

Such a beautiful beach...

The sign boldly proclaims that the town is a “plastic free zone”. Looking around, I couldn’t help but think that this is certainly another strange interpretation of “free”. The best part, though, comes when you read what’s written on the rest of the sign. Check it out:

Infertility and choked drains... all because of plastic

Related posts (possibly):

1. Do Indians have a sense of humor? AKA “Irony over the stinky river….” Sometimes, just when I...
2. You should run for office At least that’s what one of my former students told...
3. Marina Beach AKA “The sweet smelling ocean spray on Chennai’s shores….” Aah....

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

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):

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

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):

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

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() { ?>
<script type="text/javascript">
Your Fancy javascript
</script>
<?php }
add_action('wp_head', '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):

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

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):

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

Amy's in the news...

Cop: A Novel

Dan also has a few sites of his own.

No related posts.

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:

<html>
  <head>
    <script type="text/javascript" src="http://www.google.com/jsapi"></script>
    <script type="text/javascript">
    google.load("visualization", "1", {packages:["imagesparkline"]});
    google.setOnLoadCallback(drawChart);
    function drawChart() {
    var data = new google.visualization.DataTable();
      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 ");
    data.addRows(11);
      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( 7,0,1100 );
	  data.setValue( 8,0,1600 ); data.setValue( 9,0,1400 );
	  data.setValue( 10,0,1500 ); data.setValue( 0,1,7200 );
	  data.setValue( 1,1,8300 ); data.setValue( 2,1,8600 );
	  data.setValue( 3,1,4900 ); data.setValue( 4,1,5000 );
	  data.setValue( 5,1,4000 ); data.setValue( 6,1,7400 );
	  data.setValue( 7,1,7200 ); data.setValue( 8,1,6000 );
	  data.setValue( 9,1,7300 ); data.setValue( 10,1,6000 );
	  data.setValue( 0,2,3250 ); data.setValue( 1,2,3600 );
	  data.setValue( 2,2,3750 ); data.setValue( 3,2,2250 );
	  data.setValue( 4,2,3250 ); data.setValue( 5,2,2400 );
	  data.setValue( 6,2,3500 ); data.setValue( 7,2,3400 );
	  data.setValue( 8,2,3250 ); data.setValue( 9,2,3250 );
	  data.setValue( 10,2,2500 ); data.setValue( 0,3,2300 );
	  data.setValue( 1,3,2500 ); data.setValue( 2,3,2400 );
      data.setValue( 3,3,2100 ); data.setValue( 4,3,2700 );
	  data.setValue( 5,3,2400 ); data.setValue( 6,3,3400 );
	  data.setValue( 7,3,2300 ); data.setValue( 8,3,2300 );
      data.setValue( 9,3,1800 ); data.setValue( 10,3,1200 );
	  data.setValue( 0,4,17500 ); data.setValue( 1,4,19000 );
	  data.setValue( 2,4,22000 ); data.setValue( 3,4,10000 );
      data.setValue( 4,4,14000 ); data.setValue( 5,4,11000 );
	  data.setValue( 6,4,16500 ); data.setValue( 7,4,14000 );
	  data.setValue( 8,4,13000 ); data.setValue( 9,4,14000 );
      data.setValue( 10,4,12500 ); data.setValue( 0,5,5700 );
	  data.setValue( 1,5,5700 ); data.setValue( 2,5,5900 );
	  data.setValue( 3,5,4100 ); data.setValue( 4,5,4500 );
	  data.setValue( 5,5,3100 ); data.setValue( 6,5,5500 );
	  data.setValue( 7,5,4800 ); data.setValue( 8,5,5800 );
	  data.setValue( 9,5,5900 ); data.setValue( 10,5,6400 );
	  data.setValue( 0,6,510 ); data.setValue( 1,6,430 );
	  data.setValue( 2,6,420 ); data.setValue( 3,6,250 );
	  data.setValue( 4,6,400 ); data.setValue( 5,6,390 );
	  data.setValue( 6,6,650 ); data.setValue( 7,6,640 );
	  data.setValue( 8,6,750 ); data.setValue( 9,6,840 );
	  data.setValue( 10,6,870 ); data.setValue( 0,7,1650 );
	  data.setValue( 1,7,1600 ); data.setValue( 2,7,2000 );
	  data.setValue( 3,7,1650 ); data.setValue( 4,7,1600 );
	  data.setValue( 5,7,1550 ); data.setValue( 6,7,1750 );
	  data.setValue( 7,7,2000 ); data.setValue( 8,7,2500 );
	  data.setValue( 9,7,2750 ); data.setValue( 10,7,3250 );
    var chart = new google.visualization.ImageSparkLine(document.getElementById('chart_div'));
    chart.draw(data, {width: 170, height: 40, color: '#545454',
	showAxisLines: false, showValueLabels: false, labelPosition: 'left'});
    }
    </script>
  </head>

  <body>
    <div id="chart_div"></div>
  </body>
</html>

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):

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

Here’s the abstract:

When one surveys news reports today, mention of disasters seem to be commonplace. And, quite often, there is a lot of response to disasters. Aid agencies channel money or other forms of relief directly to communities who need it or to organizations who are better prepared to implement response work. Governments create plans to offer rehabilitation support, or find some other way to compensate those who are affected by disasters. Academicians write reports comparing one disaster to similar disasters, and theorize about what could have been done to minimize the impact of the disaster.

But where is the community in this post-disaster scenario? And what about the communities who have not suffered catastrophes? Are they safe? Is that enough? Is it appropriate to merely respond to disasters, or is there a better way to approach disaster risk reduction? And what does this mean for a development organization?

ACEDRR believes that there is simultaneously a positive and negative relationship between development and disasters. However, development efforts have incredible potential to contribute to disaster risk reduction and to help create a “culture of preparedness”. Development practitioners have a responsibility to be aware of this continuum and use it to guide their work and to build knowledge about disaster preparedness and prevention.

This primer is by no means a complete account of the relationship between disasters and development. However, it is hoped that this primer can serve as an introduction for practitioners to become more sensitized to the relationship, and that they use this awareness to change from working in what is mostly a reactive manner, to working in a proactive one. It is also hoped that this primer can lay a foundation for further discussions and research—not discussions and research designed around communities, but ones which include the community as an integral partner and as a stakeholder whose traditional wisdom might be able to help us with some of the more complicated issues we face in our rapidly modernizing world.

And, here’s the report itself.

[Cross-posted at ananda.mahto.info. Spread the link around!]

Related posts (possibly):

1. An interview with Ananda Mahto Every year, pretty much everyone available from DHAN Foundation and...
2. You should run for office At least that’s what one of my former students told...
3. And when the numbers go against what you have always said…. Today [note: this was actually written about a week ago,...

And, a chance for me to reminisce by posting a very old recording of Amy’s story:

Amy’s Story (ogg) | Amy’s Story (mp3)

Amy's Story

Related posts (possibly):

1. DWAB: New and Found Songs Keep the Music Playing New and found songs keep the music playing, but not...
2. DWAB: The Song that Didn’t Make it I know… you are all rockin’ out so hard to...
3. Hi Drocoele, crowin’ under the coconut trees…. Wow. Another post so quickly. And more new music. This...