A beautiful periodic table from 1949

The classic visualisation of the periodic table above is from LIFE magazine of 16 May 1949. It has been doing the rounds, with considerable justification.

This visualisation uses both position and colour to show relationships between the elements. For example, purple colouration and a dashed arrow is used to link the elements of Group VIIB (Manganese, Technetium, Rhenium) to those of Group VIIA (Fluorine, Chlorine, Bromine, Iodine, Astatine). The original caption can be found here.

Venus nears inferior conjunction

The planet Venus is about to reach inferior conjunction, the point of closest approach to Earth. Currently, Venus is 43.8 million kilometres (27.2 million miles) away. In a telescope, it is visible as a large, thin crescent – this video (by Stanko Jankovic) shows the planet on December 22^nd:

For the current distance to Venus, see Wolfram’s calculator or the live diagram of the solar system at Fourmilab, which includes images (green lines show orbits below the plane of the ecliptic):

Best Scientific Visualizations of 2013

Wired is listing their “Best Scientific Visualizations of 2013.”

Included on their list is the interesting network diagram below, from the paper “Parasites Affect Food Web Structure Primarily through Increased Diversity and Complexity” by Jennifer Dunne et al. (PLoS Biology, Vol. 11, No. 6, June 2013) – a paper which I have previously mentioned.

Merry Christmas!

The Christmas fresco above, by Giotto, shows the Star of Bethlehem as a comet (top centre). It is likely that this fresco depicts Halley’s Comet, which Giotto saw in 1301, about two years before he began the series of frescos of which this is part. This work by Giotto was celebrated in the name of the Giotto spacecraft, which observed the comet in 1986.

Let me take this opportunity to wish all my readers a very happy Christmas.

Three new plant and fungus species described in 2013

Nepenthes kitanglad is an endangered tropical pitcher plant found only on Mount Kitanglad in the Philippines. Specimens had been reported in 2009 as N. saranganiensis, but closer examination found that the plants from Mount Kitanglad formed a distinct species – see Martin Cheek and Matthew Jebb, “Recircumscription of the Nepenthes alata group (Caryophyllales: Nepenthaceae), in the Philippines, with four new species” (photo: Stewart McPherson)

Ampelocissus asekii is a vine found in the mountain forests of Morobe Province in Papua New Guinea. It was recognised as a distinct species based on herbarium studies – see Jun Wen, Robert Kiapranis, and Michael Lovave, “Ampelocissus asekii J. Wen, R. Kiapranis & M. Lovave, a new species of Vitaceae from Papua New Guinea”

Amanita augusta is a mushroom found in California and the Pacific Northwest of North America. It was formerly known under the European name A. franchetii, but was long suspected to be and is now confirmed as a distinct species – see Dimitar Bojantchev and R. Michael Davis, “Amanita augusta, a new species from California and the Pacific Northwest” (photo: Darvin DeShazer)

Three new animal species described in 2013

Enyalioides binzayedi is a lizard from Peru – see Pablo J. Venegas, Omar Torres-Carvajal, Vilma Duran, and Kevin de Queiroz, “Two sympatric new species of woodlizards (Hoplocercinae, Enyalioides) from Cordillera Azul National Park in northeastern Peru”

Zospeum tholussum is cave-dwelling snail from Croatia – see Alexander M. Weigand, “New Zospeum species (Gastropoda, Ellobioidea, Carychiidae) from 980 m depth in the Lukina Jama – Trojama cave system (Velebit Mts., Croatia)”

Otus jolandae is an owl from Lombok in Indonesia, which was previously known, but not recognised as a distinct species – see George Sangster, Ben F. King, Philippe Verbelen, and Colin R. Trainor, “A New Owl Species of the Genus Otus (Aves: Strigidae) from Lombok, Indonesia”

The Hobbit – an unexpected deficiency

Joseph Hopkinson (a British student) and Dr. Nicholas Hopkinson have published a tongue-in-cheek paper in The Medical Journal of Australia looking at some health issues in Tolkien’s The Hobbit. The Hopkinsons suggest that the orcs in that novel were defeated partly because they were sun-deprived (and hence deficient in Vitamin D). The chart below summarises their findings:

This wonderful and timely paper certainly deserves an award for its potential benefits in science education. At the risk of being a grumpy old Scrooge, however, I can’t help but think that their limited textual dataset has led them to somewhat underestimate the Vitamin D content of a diet rich in fish:

So sleek, so fair!
What a joy to meet!
We only wish
to catch a fish,
so juicy-sweet!

Photo: Gage Skidmore (at 2012 Comic-Con in San Diego)

List processing in NetLogo: a tutorial

NetLogo is one of my favourite simulation tools, as I have said in a previous tutorial. It is so easy to use that children can program in it, and very sophisticated functionality can be delivered with surprisingly little code.

However, this ease of use has attracted scorn from some quarters, with one blogger even suggesting that “using NetLogo signals that you don’t know how to do real programming.” A colleague of mine once expressed a similar sentiment. Nothing could be further from the truth – such comments are like suggesting that The Lord of the Rings is unsuitable for adults simply because children enjoy it.

In fact, NetLogo incorporates much of the power of Lisp. In this tutorial, I will highlight the power of the list operators foreach, map, and filter, through two classic list-processing case studies: the Eight Queens puzzle (illustrated above) and the Sieve of Eratosthenes. NetLogo also includes a reduce operator, which allows non-parallel versions of the MapReduce style of programming.

Eight Queens

The Eight Queens puzzle requires placing eight queens on a chessboard so that none threaten each other – i.e. so that none are in the same row, column, or diagonal. Following a relatively standard approach, we will place exactly one queen in each column, representing a solution as a list of row positions, indexed from 1. The picture above shows the solution [1 5 8 6 3 7 2 4], for example. Here the column positions [1 2 3 4 5 6 7 8] are implicit.

We can add a new queen to such a list with the lput operator (fput and lput are equally efficient in NetLogo 5.0, so there is no longer any need to prefer fput). To test the (column,row) pairs (i,j) and (m,n) for mutual threats, we check for queens in the same row or diagonal (our placement strategy will guarantee exactly one queen per column):

to-report add-queen [ lst n ]
  report lput n lst 
end

to-report threatens [ i j m n ]
  report (j = n) or (i + j = m + n) or (i - j = m - n)
end

We can test a new row position n for compatibility with an existing partial solution lst by calculating the column the new queen will be in: ((length lst) + 1). We then use a foreach loop to iterate through the existing solution. The command block inside this loop refers to the current list element as ?. Simultaneously, we use i to iterate through the column positions in the existing solution. The combination is safe if we find no threats:

to-report safe [ lst n ]
  let m ((length lst) + 1)
  let i 1
  foreach lst [
    if (threatens i ? m n) [ report false ]
    set i (i + 1)
  ]
  report true
end

The main reporter takes two arguments: the number of queens to place (n) and the number of rows (usually 8). It returns a list of all possible solutions: a list of lists. If n = 0, there is one way of placing zero queens (the sole solution is represented by the empty list). Otherwise, we recursively place n - 1 queens (giving lst), and for each solution in that list try all possible rows in the next column (using a while loop). All solutions that pass the safety check are accumulated in res, which is the value returned:

to-report queen-solutions [ n num-rows ]
  if-else (n = 0)
    [ report [ [] ] ]
    [ let lst (queen-solutions (n - 1) num-rows )
      let res []
      foreach lst [
        let i 1
        while [i <= num-rows] [
          if (safe ? i) [ set res (lput (add-queen ? i) res) ]
          set i (i + 1)
        ]
      ]
      report res
    ]
end

At the starting level, we pass in the same number (usually 8) in both arguments. We also need a global variable to store a list of solutions:

to-report all-queen-solutions [ n ]
  report (queen-solutions n n)
end

globals [
  queens
  scan
]

The Queens button executes the following code. For 8 queens, generating all the solutions takes about 0.1 seconds, and this is done only on the first button-press. Subsequent button-presses iterate through the solution list. We assume that the world is set up so that the bottom left patch is (0,0). The size of the world can be changed, as long as it remains square.

;; code for QUEENS button
to queens-go
  ;; remove any old turtles
  ask turtles [ die ]
  
  ;; set up chessboard pattern
  ask patches [
    if-else ((pxcor - pycor) mod 2 = 0) [ set pcolor white ] [ set pcolor black ]
  ]
  
  ;; the first time the QUEENS button is pressed, calculate list of all solutions
  if (queens = 0) [
    reset-timer
    set queens (all-queen-solutions world-width)
    type (length queens) print " solutions"
    type timer print " seconds taken"
    set scan 0
  ]

  ;; every time the QUEENS button is pressed, display one solution
  ;; increment scan as an index into the list of all solutions  
  let q (item scan queens)
  set scan (scan + 1)
  type "solution #" type scan type ": " print q
  if (scan = (length queens)) [ set scan 0 ]
  
  ;; display a solution by placing turtles in the world
  ;; convert coordinates assuming bottom left corner of world is (0,0) 
  let i 1
  foreach q [
    crt 1 [
      setxy (i - 1) (world-width - ?)
      set shape "face happy"
      set color orange
      set size 0.8
    ]
    set i (i + 1)
  ]
end

;; RESET button erases everything
to reset
  clear-all
  reset-ticks
end

Sieve of Eratosthenes

The Sieve of Eratosthenes finds all prime numbers up to a specified maximum. We again show the result by placing turtles, so that the top row of the image above displays [2 3 5 7]. We begin with a utility function to generate a list of numbers from m to n:

to-report sequence [ m n ]
  let res []
  let i m
  while [i <= n] [
    set res (lput i res)
    set i (i + 1)
  ]
  report res
end

The main sieving code takes a (non-empty) list lst (starting with the prime fst) and a maximum number maxn. If fst is large enough, we are done. Otherwise, we use filter to remove all multiples of fst, by forming the list a of entries satisfying [? mod fst > 0]. We then recursively apply sieve to that list, giving b. The final result puts fst back on the front of b:

to-report sieve [ lst maxn ]
  ;; assume lst is not empty and that first element is prime (we will start with 2)
  let fst (first lst)
  if-else (fst * fst > maxn) 
    [ report lst ]
    [ let a (filter [? mod fst > 0] lst)
      let b (sieve a maxn)
      report (fput fst b) ]
end

Two additional utility functions extract column and row positions for a prime, again assuming that the world is set up so that the bottom left patch is (0,0):

to-report latitude [ n ]
  report ((n - 1) mod world-width)
end

to-report longitude [ n ]
  report ((world-width - 1) - floor ((n - 1) / world-width))
end

The Primes button executes the following code. The main activity is a call to sieve. We use the two utility functions to get a list of all column positions and a list of all row positions, using map to apply a tranforming reporter to all elements of a list (we show two different ways of calling map). Finally, when foreach is wrapped in brackets it can iterate through multiple lists simultaneously. We use that here to iterate through the row and column positions for the primes:

;; code for PRIMES button
to primes-go
  ;; remove any old turtles
  ask turtles [ die ]
  
  ;; set up chessboard pattern
  ask patches [
    if-else ((pxcor - pycor) mod 2 = 0) [ set pcolor 48 ] [ set pcolor 28 ]
  ]
  
  ;; calculate the primes
  let maxn (world-width * world-height)
  let numbers (sequence 2 maxn)
  let primes (sieve numbers maxn)
  type "primes " print primes
  
  ;; place turtles at prime positions
  ;; brackets identify the multi-argument version of foreach
  ;; we illustrate two different ways of using map
  (foreach (map latitude primes) (map [longitude ?] primes) [
    crt 1 [
      setxy ?1 ?2
      set shape "circle"
      set color blue
      set size 0.8
    ]
  ])
end

The complete NetLogo file can be found at Modeling Commons.

Data visualisation and “small multiples”

Having mentioned the “small multiples data visualisation technique,” here is an image montage that gets the idea across as well as a non-technical example can, I think. Similarities and differences are what to look for:

Blogroll: Thumbs Up Viz

Thumbs Up Viz is a blog which collects good examples of data visualisation. One post from a while back shows the NASA image below of all 12 Gemini launches, as an example of the “small multiples technique” (although I’m not quite sure what the message is supposed to be in this case). However, there’s lots more to see on the blog, including a fantastic other example of small multiples on the Washington Metro.