Teaching Haskell To Juggle

by Phil Freeman on 2013/05/25

While recently learning some new juggling tricks, I decided to write a few Haskell functions to find valid patterns.

Siteswaps are a method of describing the throws involved in various juggling patterns. I'm only interested here in so-called vanilla siteswaps, where a single ball is thrown from each hand, and hands take turns to throw balls. I'll give a very basic overview of vanilla siteswaps and associated ideas, before showing the Haskell code. Interested readers are encouraged to survey the online literature covering the theory of siteswaps, which is extensive.

The numbers in a siteswap pattern represent the heights to which the various balls are thrown. Odd numbers indicate throws to the opposite hand, and even numbers indicate throws to the same hand. The larger a number, the higher the throw, and the longer the ball will be in the air.

For example, the siteswap pattern 33 represents the three ball cascade. We can read it as follows: the first hand throws a ball to height 3 into the second hand on beat 1, followed by the second hand throwing a ball to height 3 into the first hand on beat 2. After this, the pattern repeats. The first ball will land in the second hand on beat 4, three beats after it was thrown.

The siteswap pattern 441 represents a 3-ball pattern which can be inserted as a trick into the regular 3-ball cascade. The notation indicates that the trick consists of a self-throw from each hand to height 4 on beats 1 and 2, followed by the first hand throwing a ball quickly to the second hand on beat 3.

The 3-ball pattern 441 (left), and the same pattern inserted into the 3-ball cascade (right).

The number of props used in a pattern is given by the average of the numbers in the pattern. We can see therefore that the 3-ball cascade does indeed use 3 props, as does 441.

Not every sequence of integer values constitutes a valid siteswap pattern. We need to make sure that on each beat, at most one ball lands in the appropriate hand. For example, if we know that on a given beat, a ball is already scheduled to land in the opposite hand on the next beat, then we cannot throw a 1, since that will result in a collision.

This determines a graph of underlying states and valid transitions, whose paths correspond to the valid siteswap patterns. The Haskell code below will allow us to query this graph, and ask things like "what is the complete list of valid n-ball tricks which can be inserted into a n-ball cascade?"

The nodes of the graph will need to contain enough data to answer whether or not a ball is scheduled to land n beats in the future for all n < N for some N. We could therefore take the type of states to be a list of booleans of length N. However, it is more conventional to pack these booleans as bits into a single integer and to refer to states by this integer, so we will take the type of states to be a (newtype-wrapped) integer. The number of bits is equal to the maximum height to which a ball will be thrown.

For example, the 3-ball cascade stays in state 7 = 2^0^ + 2^1^ + 2^2^ = 111~2~. On each beat n, a ball is scheduled to land on beats n, n+1, and n+2. Throwing a ball to height 3 will schedule a ball to land on beat n+3.

We will represent heights, patterns and states as follows:

import Data.Bits
import Data.Maybe
import Data.List
import Control.Monad
import Control.Applicative
newtype Height = Height { height :: Int } deriving (Show, Eq, Ord)
newtype Pattern = Pattern { pattern :: [Height] } deriving (Show, Eq)
newtype State = State { state :: Int } deriving (Show, Eq, Ord)

We can transition to a new state by throwing a ball to a given height. If the first bit of the state is zero, then there is no ball scheduled to land, hence nothing available to throw, and the only valid throw is a fake throw to "height" 0. If the first bit is a one, then we can throw to any height h such that the bit at position h + 1 is a zero.

A valid throw is indicated by a return value constructed using Just. An invalid throw returns Nothing.

throw :: Height -> State -> Maybe State
throw (Height 0) (State s) | (s .&. 1) == 0 = 
  Just $ State $ s `shiftR` 1
throw (Height h) (State s) | h > 0 && ((1 `shift` h) .&. s) == 0 = 
  Just $ State $ (s `shiftR` 1) .|. (1 `shift` (h - 1))
throw _ _ = Nothing

We can also use foldM to attemt to throw a pattern. The return value will be Nothing if any throw was invalid.

throwMany :: Pattern -> State -> Maybe State
throwMany p s0 = foldM (flip throw) s0 (pattern p)

To find valid patterns, we need to find cycles in the graph of states and throws.

A graph can be represented by a list of vertices together with a list of edges:

type Graph v e = ([v], [(v, v, e)])

Cycles are just paths whose start and end vertices coincide. We can find paths by choosing a start vertex and performing a depth first traversal of the graph, keeping track of the vertices we have already visited:

paths :: (Eq v) => Graph v e -> [(v, v, [e])]
paths (vs, es) = 
  [ (v1, v2, p) 
  | v1 <- vs
  , (v2, p) <- paths' v1 es [] ] 
  paths' v es visited = (v, []) : 
    [ (v3, (e:p))
    | (v1, v2, e) <- es
    , v1 == v
    , not $ v2 `elem` visited
    , (v3, p) <- paths' v2 es (v1:visited) ]

Cycles are then given by filtering the list of paths:

cycles :: (Eq v) => Graph v e -> [(v, [e])]
cycles (vs, es) = [ (v1, p ++ [e]) 
                  | (v1, v2, p) <- paths (vs, es)
                  , not $ null p
                  , (v2', v3, e) <- es
                  , v2 == v2'
                  , v3 == v1 ]

In order to generate the graph of states and throws, we need to fix a maximum height and a number of balls to throw.

The number of 1 bits in a state represents the number of balls in the air:

countBits :: Int -> Int
countBits 0 = 0
countBits 1 = 1
countBits n = let (d, r) = n `divMod` 2 in countBits d + countBits r

The function throw is the transition function which can be used to tell whether or not a throw corresponds to an edge in the graph. Here is a function which generically constructs a graph from such a function:

generateGraph :: (Eq v) => (e -> v -> Maybe v) -> [v] -> [e] -> Graph v e
generateGraph transition vs es =
  let edges = [ (v1, v2, e) 
              | v1 <- vs 
              , v2 <- vs
              , e <- es
              , transition e v1 == Just v2] in (vs, edges)

We can now construct the state transition graph for a number of balls with a maximum throw height by using generateGraph with throw. We can use countBits to construct the set of states given the maximum height maxHeight.

graph :: Height -> Int -> Graph State Height
graph (Height maxHeight) numBalls = 
  let maxState  = (1 `shiftL` maxHeight) - 1
      states    = map State $ filter ((== numBalls) . countBits) [0..maxState] in
  generateGraph throw states (map Height [0..maxHeight])

Enumerating valid patterns for a number of balls with a maximum throw height is as simple as finding cycles in this graph:

validPatterns :: Height -> Int -> [(State, [Height])]
validPatterns maxHeight numBalls = cycles $ graph maxHeight numBalls

For example, we can find all 3-ball patterns with a maximum height of 4, along with their initial states, as follows:

ghci> map (state *** map height) $ validPatterns (Height 4) 3

Finally, we can answer this question from earlier in the post: what is the complete list of valid n-ball tricks which can be inserted into a n-ball cascade?

A trick can be inserted into the n-ball cascade whenever its initial and final states equal the steady state 2^n^-1 of the n-ball cascade.

tricks :: Height -> Int -> [[Height]]
tricks maxHeight numBalls = 
  map snd 
  $ filter ((== (State (2^numBalls - 1))) . fst) 
  $ validPatterns maxHeight numBalls

For example, here are the tricks with maximum height 4 which can be inserted into the 3-ball cascade:

ghci> map (map height) $ tricks (Height 4) 3

Addendum: Juggling Animator in Elm

I originally wrote this juggling animator in Haskell using the HOpenGL library for rendering, and later ported the code to Elm.

First, we need to define some constants, including the pattern to throw:

-- The fraction of time spent holding the ball in the hand
pauseTime = 0.35
-- The number of milliseconds per beat
timePerThrow = 300
-- The displacement of the "hands" during a throw
handMovement = 0.2
-- The pattern to animate
pattern = [5]

A key function is rotatePattern, which is used to rotate a list of heights by a number of steps. This is used to shift a pattern after a throw occurs, or to adjust a pattern for each ball being juggled.

rotatePattern : Int -> [a] -> [a]
rotatePattern n xs =
  if | n < length xs -> drop n xs ++ take n xs
     | otherwise     -> rotatePattern (n - length xs) xs

Given the current time (in units of beats), we can calculate the height of the current throw, and the coordinates of the current ball by repeatedly rotating the pattern:

heightAtTime : [Int] -> Float -> Int
heightAtTime hs t =
  let h = head hs in
  if | t < toFloat h     -> h
     | otherwise         -> heightAtTime (rotatePattern h hs) (t - toFloat h)
xAtTime : [Int] -> Float -> Float
xAtTime hs t =
  let h = head hs in
  if | t < pauseTime                       -> t / pauseTime * handMovement
     | (t < toFloat h) && (h `mod` 2 == 0) -> handMovement * (toFloat h - t) / (toFloat h - pauseTime)
     | t < toFloat h                       -> handMovement + (1 - handMovement) * (t - pauseTime) / (toFloat h - pauseTime)
     | h `mod` 2 == 0                      -> xAtTime (rotatePattern h hs) (t - toFloat h)
     | otherwise                           -> 1 + xAtTime (rotatePattern h hs) (t - toFloat h)
yAtTime : [Int] -> Float -> Float
yAtTime hs t  =
  let h = head hs in
  if | t < pauseTime -> 0
     | t < toFloat h -> (t - pauseTime) / (toFloat h - pauseTime)
     | otherwise     -> yAtTime (rotatePattern h hs) (t - toFloat h)

The x-coordinate needs to be clipped to the range 0-1. Reflections occur at integer values of x, since the x coordinate represents the total displacement along the x-axis.

clip : Float -> Float
clip x =
  if | x > 1     -> 1 - clip (x - 1)
     | x < 0     -> clip (0 - x)
     | otherwise -> x

We can now compute the position of each ball. I have hard-coded the width and height of the canvas to 300 pixels here, but these could be provided as parameters.

project : Float -> Float -> Int -> Int -> (Float, Float)
project x y h maxHeight = 
    xProj = 280.0 * x - 140.0
    yProj = 280.0 * (4.0 * toFloat h * y * (1.0 - y) / toFloat maxHeight) - 140.0
    (xProj, yProj)
positionOfBallAt : [Int] -> Int -> Float -> Int -> (Float, Float)
positionOfBallAt heights maxHeight time index =
    x      = xAtTime heights time
    y      = yAtTime heights time
    cx     = clip (toFloat index + x)
    h      = heightAtTime heights time
    project cx y (h - 1) maxHeight

positionOfBallAt gives the position of the ball, and circle is used to render it. The frame function renders each ball as a circle at its current position:

frameFor : [Int] -> Int -> Int -> Int -> Int -> Form
frameFor heights timePeriod maxHeight millis index =
    startMillis     = index * timePerThrow
    relativeTime    = toFloat ((millis - startMillis) `mod` timePeriod) / toFloat timePerThrow
    rotatedPattern  = rotatePattern index heights
    position        = positionOfBallAt rotatedPattern maxHeight relativeTime index
    circle 10 |> filled black |> move position
frame : [Int] -> Int -> Element
frame heights millis = 
    period          = 2 * sum heights
    timePeriod      = timePerThrow * period
    maxHeight       = maximum heights
    [0 .. period - 1] |> List.map (frameFor heights timePeriod maxHeight millis) |> collage 300 300 

main simply invokes frame to render the current scene once every millisecond (or as fast as possible):

main : Signal Element
main = lift (frame pattern . round) (every millisecond)