I have discovered more than once in recent free-time projects, that
can help make code much simpler to write and understand. In fact, it makes
some problems feel tractable, when at first they felt as though a complicated
"brute force" technique was needed.
I'll give some examples of where simply adjusting coordinate systems
made my problems much easier to understand and solve.
By changing to the right coordinate system,
in the problem can become more apparent.
One project I have been working on in my spare time is a digital instrument
that uses the Lattice Boltzmann Method to simulate fluids. In it, I have
fill the screen with hexagons (2DQ7), where each hexagon simulates how pressure
waves move through a two dimensional surface. Thus, the problem arises:
“In what structure store the hexagons, how would I map hexagon indices
to screen positions, and how do I find neighboring hexagons?”
When I started the project, I approached these question the same way I would
a lattice of squares (2DQ9). Working with pixels much longer than I have
hexels, it was difficult to start from
The nice thing with a lattice of squares / screen of pixels is that a 2D array
maps directly onto it in a reasonably straight-forward manner. In fact, it can
be as simple as directly translating array index to pixel position.
I attempted to do a similar mapping with hexagons, and it “worked,” but
I went through many iterations and errors as I walked through the different cases for
drawing and finding neighbors. Doing things this way, I was shoving a hexagonal peg
into a square hole.
Doing this was frustrating in two ways. The first is that I could draw such a numbering by
hand easily enough, but it took many wrong implementations translating the procedure to
code. The drawing code for even rows and that for odd rows ends up being very different
from each other. Second, even once the code was implemented correctly, it felt wrong
to be doing things this way. After all, a hexagon in an even row looks exactly the same
as a hexagon in an odd row. The code should reflect this symmetry. My code reaked of
Ideally, we can find a mapping where hexagons are treated more symmetrically. That is,
the mapping from 2D array index to screen position should be linear. Meaning, it should
be a simple addition and multiplication. There should be no difference in even versus odd
rows or any other unnecessary distinction between the different hexagons.
In this light, we see that our choice to attempt to fit the x and y directions at 90 degrees
is a poor fit for a lattice of hexagons. Instead, we should choose an x and y direction (the
basis in linear-algebra-speak)
Choosing an x and y direction not 90 degrees apart may look strange, but to do so when
drawing a grid of hexagons will cause more pain that needed. Had I looked at the problem
this way from the beginning it would have saved me at least four iterations of bug fixing,
finding missing cases in drawing code and neighbor finding code.
Looking at symmetries in coordinate systems is also helpful when looking at the
n queens problem.
The first part of this is to specify what exactly it means for a set of queens
to be attacking each other. Queens are said to be attacking each other if they
lie in the same row, column, or diagonal.
Can we translate the notion of queens attacking each other into mathematics?
If we are given a set of queens as (row, column) positions, can we determine
if any are attacking each other?
Let's start with the rows. If more than one queen shares a row, then these
queens are said to be attacking each other along that row. So, looping through
all the row coordinates of the queens and finding the existence of duplicates
(with a hash set, by sorting, or whatever other method you'd like to find duplicates)
is equivalent to finding out if the queens are attacking along some row. The
same argument applies to finding queens attacking along some column.
Is there a simple way to find queens attacking along the diagonals? Would it
work in the same way as the rows and columns. It feels as though the problem
and solution should be symmetric. We are just finding if the queens lie along
a certain line in the row, column, and diagonals cases, after all.
Just as with the hexagons problem, with a change of coordinates
(in this case, by rotating 45 degrees and scaling), what we at first thought
was difficult now looks easy. By converting the queens' (row, column) coordinates
to (row + column, column - row) coordinates, what we have really done
is convert the queens' coordinates to (south-east diagonal, south-west diagonal)
With this new set of coordinates in hand, we can use the exact same duplicating
finding method as we did with rows and columns to determine if queens are attacking
along one of the diagonals.
Changing coordinates can highlight valuable symmetries when solving programming
can both prevent bugs and make problems tractable. Finding
symmetry is a very important step.
By taking the time to find symmetries in the problems I've encountered in my
side projects, I could have saved myself from a lot of debugging time.