This is the second post about z-quads, a spatial coordinate system. In the first post I outlined how they work and described how to jump between quads at different zoom levels. In this post I’ll look at how to determine whether one quad contains another, and how to find the common ancestor of two quads.

## Containment

Given two quads *q* and *s*, how do we determine if *q* contains *s*? It’s pretty simple – there’s two cases to consider.

The one case is that the zoom level of *q* is higher than the zoom level of *s*. (Let’s call them *z _{q}* and

*z*). If

_{s}*q*is zoomed in more than

*s*then it can’t contain

*s*because it’s clearly smaller. So now let’s assume that

*q*is at the same level or higher than

*s*. If

*s*is contained in

*q*then that’s just another way of saying that

*q*is

*s*‘s ancestor. So if you get the ancestor of

*s*that’s at the same level as

*q*then you should get –

*q*. In other words,

contains?(*q*, *s*) = (*z _{q}* ≤

*z*) and (ancestor(

_{s}*s*,

*z*–

_{s}*z*) =

_{q}*q*)

Pretty simple right? By the way, now you’re seeing why I pointed out before that the ancestor operation is defined for *n*=0: that’s what you’re using if you do contains?(*q*, *q*), which obviously you’d expect to be true.

This is the first operation where the zoom level appears explicitly and I’ll get into how to determine that for a given quad in a second. But first I’ll complete containment and talk about finding the most specific common ancestor of two quads.

## Common ancestor

Let’s say we have two quads, call them *q* and *s* again, and you want to find the most specific ancestor of the two. That is, the ancestor that contains both of them and where no child also contain them both – since that would make the child more specific. This is well-defined since any two quads have, if no other, at least the trivial ancestor `0`

in common.

The first step is to normalize *q* and *s* to the same zoom level. We’ll assume that *s* is zoomed in at least as much as *q* – if it’s not you can always just have an initial step that swaps them around. We can zoom *s* out to *z _{q}* and it won’t change what their common ancestor is because we know that is has to be at level

*z*or above for it to be an ancestor of

_{q}*q*. Let’s use

*t*to refer to the result of zooming

*s*out to

*q*‘s level. So now we have

*q*and

*t*which are both a zoom level

*z*.

_{q}To do the rest of the computation we need a bit more intuition about how the space of quad scalars is structured. As I’ve mentioned a few times at this point, because quads are numbered in z-order within one level all the descendants of a particular quad are contiguous, and so are the scalars. That means that you can split the binary representation of a scalar into 2-bit groups where each group corresponds to a subdivision of the whole space.

Here’s an illustration of how that works out for the scalars at zoom-2. You can think of the binary representation of the scalar, here for instance `9`

, as consisting of two groups: the top two bits indicate which 2×2 subdivision the quad belongs to, and the bottom two bits as the 1×1 subsubdivision within that one.

If you’re given two scalars, let’s take 9 and 11, and you write their binary representations together, then their common ancestor almost jumps out at you,

9: 10 01 11: 10 11

You can tell from the top two bits that they’re both in the same subdivision but then they’re in different subsubdivisions. So the most specific common ancestor is the one that’s filled with 8s above.

This gives you a hint of how to find the most specific common ancestor more generally: you take the two scalars, then you see which 2-bit groups are different, and then you zoom out just enough that you discard all the groups that are different and keep the ones that are the same. You can find the highest bit where two numbers are different by xor’ing them together and taking the highest 1-bit in the result:

9: 10 01 11: 10 11 xor: 00 10

Here the highest different bit is at 2 so they’re different at the lowest zoom level but then they’re the same. So their most specific common ancestor is the quad you get by zooming out one step from either of them. More generally, the formula for getting the most specific common ancestor of two quads *q* and *t* at the same zoom level *z* is,

msca(*q*, *t*, *z*) = ancestor(*q*, ffs((*q* – *b _{z}* xor

*t – b*) + 1) / 2)

_{z}Here ffs is find-first-set which returns the index of the highest 1-bit in a word, 0 if there are none. The (*x*+1)/2 part is to get from a bit index to a zoom level. For instance if the highest set bit is 1 or 2, as in the example, (*x*+1)/2 will be 1.

At this point let’s just recap quickly. Given a quad you can get an ancestor, a descendant, and you can determine how it is related to any of its ancestors. Given two quads you can determine whether one contains the other, and you can find the most specific common ancestor. All in a constant, low, number of bit operations. There are more operations to come but already I think we’ve got a big enough library of operations to be useful.

I’ve glossed over a few things along the way though, particularly how to determine the zoom level for a given quad. That’s what I’ll talk about next. It’s kind of fiddly so if you’re okay with trusting that it can be calculated efficiently then you can just skip this part and go on to the part where I talk about how to convert from regular floating point coordinates to quads and back.

Otherwise, let’s go.

## Zoom

Given a quad, what is its zoom level?

Since quads at higher zoom levels have higher numeric values one way to answer this is to just compare with the biases. If a value is between *b*_{4} and *b*_{5} then it must have zoom level 4, and so on. Since the biases are sorted you can even do binary search. But you can be a lot smarter than that.

Here’s an illustration of where the quads at zoom level 4 and 5 are located on the numbers line,

The zoom-4 quads start at 85 and end at 340, then the zoom-5 quads start at 341 and run until 1364 where zoom-6 starts. Each range of quads contains values from three different 2-power intervals: zoom-4 contains values from the 2^{6} to the 2^{8} interval, zoom-5 from 2^{8} to 2^{10}, and so on. This suggests that determining the highest set one-bit in the quad is a good place to start.

As an example, say the highest one-bit is 8 or 9. That is, the quad is between 256 and 1024. If you look at the numbers line then you see that there are two possibilities: if it’s smaller than *b*_{5}, 341, then it’s at level 4, otherwise it must be at level 5. Similarly, if the highest bit is at index 10 or 11, that is a value between 1024 and 4096, then the level is 5 or 6 depending on whether the quad is larger than *b*_{6}, 1365.

There’s a general principle working here. Say highest set bit of a quad is at index *k*. The zoom level will be *c*=*k*/2 if the quad is is smaller than *b*_{c+1}, otherwise it’s *c*+1.

As an illustration, let’s try this with one of the quads from the introduction, `171171340006`

. The highest 1-bit is at index 37 so *c* is 18. This means that that quad is at zoom level 18 or 19. The boundary between the two is *b*_{19} which is 91625968981. This is less than the quad’s value so the result must be 19.

Okay so this almost gives us a fast way to calculate the zoom level. The one thing that’s missing is: how to get an arbitrary zoom bias quickly – how do you know that *b*_{19} is 91625968981? There’s only a small number of bias values of course so you can just put them in a table, but you can also calculate them directly. The thing to notice is that the binary representation of a bias is simple:

b_{3}: 10101 (= 21) b_{4}: 1010101 (= 85) b_{5}: 101010101 (= 341)

…and so on. They’re all alternating ones and zeroes. That’s because, as we saw before, they are made up of sums of powers of 4. That gives us a practical way to calculate them: take the binary number that consists of alternating 0s and 1s and mask out the bottom part of the appropriate size. So for *b*_{3} we mask out the bottom 5 bits, for *b*_{4} the bottom 7 and so on:

b_{z}= 0x5555555555555555 & ((1 << 2z) - 1)

I imagine there might be more efficient ways but this one works.

Calculating the zoom level isn’t particularly expensive but you need it for most operations so in my own code I typically compute it once early on and then keep it cached along with the quad itself (though it’s not something you would ever store or transmit along with the quad since it’s redundant). Even for some of the operations where you technically don’t need it it’s still useful to have it. For instance, you can get *n*th ancestor of a quad without knowing the zoom, but the operation is only well-defined if the quad’s zoom is *n* or greater so it’s nice to have the zoom around so you can make that assertion explicitly in the code.

I think that’s enough for one post. In the next part we’ll talk about how to do conversion between coordinates and quads.