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:

1. Drop caps with OpenOffice.org Writer Tutorial Level: Elementary From time to time, I like some...
2. Automation with OpenOffice.org Writer Tutorial Level: Intermediate At the Tata-Dhan Academy where I work,...
3. Making an A6 booklet in OpenOffice.org the easy way Tutorial level: Elementary I recently had to create an A6...

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

> 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 direcotry, 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 onlnie 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:

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. It’s a choropleth party with R, and everyone’s invited Map party time. For some reason this happens every once...

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:

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:

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:

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:

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:

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...

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:

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

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:

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