My post on factorization diagrams from a month ago turned out to be (unexpectedly) quite popular! I got ten times as many hits as usual the day it was published, and since then quite a few other people have created their own variations. The purpose of this post is twofold: first, to round up links to a bunch of the variations, and second, to show off some new and improved factorization diagrams!

I should mention a couple of my inspirations: first, the book You Can Count on Monsters does something similar, though it takes a more artistic and representational approach, in contrast to my strictly geometric approach. My other inspiration was Sondra Eklund’s super-cool prime factorization sweater (and other prime factorization visualizations) which uses a different color to represent each prime.

Not long after I published my original factorization diagrams post, the Internet got right to work creating the obviously needed factorization-diagram-generators. jnop reimplmented them in Javascript on jsfiddle, so you can play around with the code (and generate factorization diagrams) interactively. Alp Mestanogullari created a factorization diagram generator based on my original Haskell code, built with the Happstack web framework. And walrus simply generated the first 2000-some factorization diagrams, making them available for download (see this comment for instructions). Jason Davies also reimplemented factorization diagrams in Javascript, using D3.js.

Lucas linked to this awesome video on Youtube which is sort of related, but is so freaking awesome it really doesn’t matter how related it is, you should go watch it!

The Bayesian Observer made some variant diagrams showing integers as multi-level trees, grouped by prime factors.

Of course, it couldn’t be long before someone had the idea of animating the factorization diagrams. First Sean Seefried created this page with a simple animation of each factorization diagram turning into the next. Most recently, Stephen Von Worley created a much more sophisticated version which is truly wonderful: watching all those dots dance from one factorization to the next is mesmerizing.

Now, on to the improved diagrams! Quite a few people suggested improvements, some of which I’ve adopted here.

> module Factorization2 where
> 
> import Math.NumberTheory.Primes.Factorisation (factorise)
> import Diagrams.Prelude
> import Diagrams.Backend.Cairo.CmdLine
> import Data.List.Split  ( chunksOf   )
> import Data.Char        ( digitToInt )
> 
> type Picture = Diagram Cairo R2
> 
> primeLayout :: Integer -> Picture -> Picture

Layout for 2 is mostly the same as before, except I’ve moved the diagrams a bit closer together, and added some extra calls to things like reflectY and centerX as preparation for the first improvement…

> primeLayout 2 d
>   | width d >= height d = (d === strutY (height d / 3) === d # reflectY) 
>                         # centerY
>   | otherwise           = (d ||| strutX (width d / 3)  ||| d) 
>                         # centerX

…which is to lay out rotated copies of a subdiagram at the vertices of a -sided polygon, as suggested by Mark Lentczner. This makes the diagrams much more symmetric and aesthetically pleasing.

> primeLayout p d = (mconcat $
>                    iterateN (fromIntegral p)
>                      (rotateBy (1/fromIntegral p))
>                      (d # translateY r)
>                   )

The next improvement is to add color (as suggested by Sjoerd Visscher). Instead of coloring the dots (which might look nice but doesn’t really help visually identify the factorization), we color in the area inside each prime polygon, using a different color scheme for each prime. Actually, there’s only a different color for each digit, and multi-digit primes are shown using vertical bars of color.

>                   <>
>                   colorBars p poly
>   where poly = polygon with { polyType   = PolyRegular (fromIntegral p) r
>                             , polyOrient = OrientH
>                             }
>         w  = max (width d) (height d)
>         r  = w * c / sin (tau / (2 * fromIntegral p))
>         c  = 0.75

And here are the colors I chose. They’re based very loosely on the color code for resistors. I lightened them all up a bit (by blending with white) which I think looks nice.

> colors = map (blend 0.1 white)
>   [black,red,orange,yellow,green,blue,gray,purple,white,brown]

For example, here’s the diagram for 47:

The odd primes up through each get their own color:

(Incidentally, this accounts for some of the weirdness in the mapping from digits to colors—like why grey comes in between blue and purple—because I wanted all the small primes to have nice colors!)

And here’s the diagram for :

Referring to the table of colors (and it’s not hard to memorize), we can see that .

For completeness, here’s the implementation of colorBars:

> colorBars p poly | p <= 11 = stroke poly 
>                              # fc (colors!!(fromIntegral p `mod` 10)) 
>                              # lw 0
> colorBars p poly = bars # clipBy poly
>   where
>     barColors = map ((colors!!) . digitToInt) (show p)
>     barW = width poly / fromIntegral (length barColors)
>     barH = height poly
>     bars = (hcat $ map (\c -> rect barW barH # fc c # lc c) barColors) 
>            # centerX

The code to actually generate complete factorization diagrams is almost the same as before, except I don’t reverse the factors anymore; I think drawing the factors from largest to smallest actually gives more pleasing (and intelligible) diagrams.

> factorDiagram' :: [Integer] -> Picture
> factorDiagram' []     = circle 1 # fc black
> factorDiagram' (p:ps) = primeLayout p (factorDiagram' ps)
> 
> factorDiagram :: Integer -> Picture
> factorDiagram = centerXY
>               . factorDiagram'
>               . concatMap (uncurry $ flip replicate)
>               . factorise

To show it off, here’s some code for generating a table of factorization diagrams from to :

> fd n = factorDiagram n # scaleUToY 0.8 <> square 1
> table n = vcat . map hcat . (map . map) fd 
>         . chunksOf (fromIntegral n) $ [1..n*n]

Here’s 1 to 36 as before:

And here’s 1 to 100 (click for a larger PDF):

Sweet!

I also want to play with using alternate layouts for certain primes (e.g. centered hexagonal numbers), but that will have to wait for another post since I’m almost out of time.

And yes, I plan to get some posters and/or t-shirts of these printed up. Any suggestions on a good site for that kind of thing? Of course I’ve heard of cafepress but I’m sure there are others and I’m open to suggestions…