latest news

Distractions and amusements, with a sandwich and coffee.

This love's a nameless dream.
•
• try to figure it out
• more quotes

On March 14th celebrate `\pi` Day. Hug `\pi`—find a way to do it.

For those who favour `\tau=2\pi` will have to postpone celebrations until July 26th. That's what you get for thinking that `\pi` is wrong. I sympathize with this position and have `\tau` day art too!

If you're not into details, you may opt to party on July 22nd, which is `\pi` approximation day (`\pi` ≈ 22/7). It's 20% more accurate that the official `\pi` day!

Finally, if you believe that `\pi = 3`, you should read why `\pi` is not equal to 3.

The trees along this city street,

Save for the traffic and the trains,

Would make a sound as thin and sweet

As trees in country lanes.

—Edna St. Vincent Millay (City Trees)

Welcome to this year's celebration of `\pi` and mathematics.

The theme this year is flower and flowers—in contrast to last year's understandable downturn in mood.

This year's `\pi` poem City Trees by Edna St. Vincent Millay.

This year's `\pi` day song is Sway by Laleh.

The forest was generated using an Lindenmayer system — this part of the process is relatively easy.

Integrating variation into how the trees look while keeping a clean look-and-feel took a lot of experimentation — there are many free parameters in this section.

A Lindenmayer system is a kind of parallel rewriting system. The system starts with some initial state, typically represented by a string. For example `FX`

.

On each iteration, rules are applied to each characters in the state, which replaces the character with some other character. For example, suppose we replace `X`

with `[-FX][+FX]`

. Starting with the axiom `FX`

The first three rounds of rewriting gives each give us

FX F[-FX][+FX] F[-F[-FX][+FX]][+F[-FX][+FX]] F[-F[-F[-FX][+FX]][+F[-FX][+FX]]][+F[-F[-FX][+FX]][+F[-FX][+FX]]]

It doesn't look like much, I know, but the magic happens when you interpret these characters in the context of turtle graphics. Specifically, let

F move forward distance d - turn left &theta degrees; + turn right &theta degrees; [ spawn a new turtle at this position facing at current angle ] restore previous turtle

If we set `\theta = 15\deg` then the shapes for each iteration are

We can interpret `F`

as a branch and `X`

a point were new branches grow. You can already see that by level 3 two of the branches — there's nothing in the system that prevents this, since each turtle operates independently.

Rules can be as simple or as complicated as you want and new characters to the string can be added to correspond to different turtle actions.

The rules for the `\pi` forest are quite simple. The system starts with the axiom `fX`

(grow a trunk and then branch off) and each digit corresponds to a different branching rule — the digit gives the number of branches with zero terminating a branch.

X 0 [] X 1 [---FX][++h] X 2 [----FX][+++FX] X 3 [-----FX][-FX][++++FX] X 4 [------FX][---FX][++FX][+++++FX] X 5 [-------FX][----FX][-FX][+++FX][+++++++FX] X 6 [--------FX][------FX][---FX][+FX][+++++FX][++++++++FX] X 7 [--------FX][-----FX][--FX][FX][+++FX][++++++FX][+++++++++FX] X 8 [---------FX][------FX][---FX][-FX][++FX][++++FX][+++++++FX][+++++++++FX]

where each – or + correspond to a left or right turn of 8 degrees. Any turns

The digit 9 has a special rule that sprouts a flower at the previous branching point and starts a new tree.

Also, at least step branches grow

F FF f ff g gg

with the `f`

step being a fraction `(1-1/\pi)^2 \approx 46%` of the length of `F`

and `g`

being `(1-1/\pi)^4 \approx 22%` of the length of `F`

. These shorter branch allow me to have a shorter trunk (axiom is `fX`

and not `FX`

) and a very short branch used in the rule for the digit 1, which branches off to one side while growing a little stubby branch to the other side.

There is one additional rule in which the turtle is mirrored at a branching point when a digit and the next digit have different parity (one odd and one even).

X = MX

The mirror operator makes the current turtle interpret any left turns as right turns, and vice versa.

The reason for the multiple turns in the rules is for convenience &mdsah; it allows me to define the angles of the branches as a multiple of a fixed value.

The system is grown for 6 iterations.

Here is the first tree of the forest – for digits 314159. It ends in a 9 because the rule for 9 is to grow a flower, terminate the current tree and start a new tree with the next set of digits (up to the next 9, and so on).

You can trace the digits for the tree left-to-right along the leaves. The flower of the 9 will appear on the branch of the digit immediately before it — in this case, a 5. The color of the flower petal is green (5) and the center is dark orange (first digit of the next tree).

The L-system string for this tree is below. See if you can discover what symbol is used for the flower.

ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff [-----FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [---FFFFFFFFFFFFFFFF [-------FFFFFFFFO][----FFFFFFFF][-FFFFFFFF][+++FFFFFFFF][+++++++FFFFFFFF] ] [++gggggggggggggggg] ] [-FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFM [------FFFFFFFFFFFFFFFF][---FFFFFFFFFFFFFFFF][++FFFFFFFFFFFFFFFF][+++++FFFFFFFFFFFFFFFF] ] [++++FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [---FFFFFFFFFFFFFFFF][++gggggggggggggggg] ]

To add variation to the tree, I take the tree's digits and create linear congruential generators for each of the following: branch turn angle, branch growth rate, thickness tapering and turtle angle when growing a branch.

Each generator is constructed as follows. The digits of the tree `d_1d_2d_3...d_n` are split into `a = d_1d_2d_3...d_{n-1}`, `c = d_n` and `m = d_1d_2d_3...d_n`. The generator is seeded with `X_0 = d_1` and then the next digit is `X_1 = (a X_0 + c) \; \textrm{mod} \; m`. Each output `X_i` is transformed to `y \times (2X_i/m - 1)`. Because some of the trees have a large number of digits, the operations are performed with an arbitrary precision library.

The output will be distributed in the range `[-y,y)`. The distribution will depend on the values of `a`, `c` and `m`. It might be reasonably uniform for some combinations and absolutely non-uniform for others. But here, non-uniform doesn't mean horrible — just another rule in the digit forest.

Each type of variation starts with an identical generator.

The parameters that influence the amount of variation are irrelevant — I tweaked them until I had something that looked "pretty good".

You might have noticed that because a branch growth step is doubled at each iteration, a branch is composed of 64 turtle steps. This was done so that there's lots of opportunities to sample variation along a branch. And also for boring technical reasons: SVG does not allow a path with varying thickness.

This means that variation can build up along a branch, especially if we allow the turtle to veer quite a bit as the branch grows. Remember, a branch begins to grows in a particular direction but can change course along its growth.

Below I show what happens when I crank up every variation type by 200% and by 300% (e.g. 300% moar branch growth rate jitter!). Things add up pretty quickly — I'm looking at you 79! What are you doing? Who knew the digit forest could be so complicated?

Exploring the space of variation is fun — even at 1am as I'm trying to finish this.

Below are some scenarios to get the imagination going.

The underwater scenario uses an effect in which turtle angle during branch growth is increased and constrained to be mostly up and no branch thickness change.

The prickly forest has a larger branch angle and larger branch length decay as a function of depth.

The dry forest has extreme thickness tapering and branch growth angle variation increases with each branch depth.

Finally, the bat cave is similar to the underwater case except that it has a much narrower branching angle and branch length now increases with branch depth. And one more change that's easy to spot.

So as you can see, the canonical digit forest is just one of a wide range of possible numerical environments.

A forest of digits

Celebrate `\pi` Day (March 14th) and finally see the digits through the forest.

This year is full of botanical whimsy. A Lindenmayer system forest – deterministic but always changing. Feel free to stop and pick the flowers from the ground.

And things can get crazy in the forest.

Check out art from previous years: 2013 `\pi` Day and 2014 `\pi` Day, 2015 `\pi` Day, 2016 `\pi` Day, 2017 `\pi` Day, 2018 `\pi` Day and 2019 `\pi` Day.

*All that glitters is not gold. —W. Shakespeare*

The sensitivity and specificity of a test do not necessarily correspond to its error rate. This becomes critically important when testing for a rare condition — a test with 99% sensitivity and specificity has an even chance of being wrong when the condition prevalence is 1%.

We discuss the positive predictive value (PPV) and how practices such as screen can increase it.

Altman, N. & Krzywinski, M. (2021) Points of significance: Testing for rare conditions. *Nature Methods* **18**

*We demand rigidly defined areas of doubt and uncertainty! —D. Adams*

A popular notion about experiments is that it's good to keep variability in subjects low to limit the influence of confounding factors. This is called standardization.

Unfortunately, although standardization increases power, it can induce unrealistically low variability and lead to results that do not generalize to the population of interest. And, in fact, may be irreproducible.

Not paying attention to these details and thinking (or hoping) that standardization is always good is the "standardization fallacy". In this column, we look at how standardization can be balanced with heterogenization to avoid this thorny issue.

Voelkl, B., Würbel, H., Krzywinski, M. & Altman, N. (2021) Points of significance: Standardization fallacy. *Nature Methods* **18**:5–6.

*Clear, concise, legible and compelling.*

Making a scientific graphical abstract? Refer to my practical design guidelines and redesign examples to improve organization, design and clarity of your graphical abstracts.

An in-depth look at my process of reacting to a bad figure — how I design a poster and tell data stories.

Building on the method I used to analyze the 2008, 2012 and 2016 U.S. Presidential and Vice Presidential debates, I explore word usagein the 2020 Debates between Donald Trump and Joe Biden.