I was doodling with crosses on graph paper and was surpised to see that I could cover the graph paper with only cross shapes. They also look pretty neat when colored oddly, so I wrote this code to play with them more efficiently.
The logic behind
I wanted to note how I came up with the formula for
transform_point. I need to talk to my old Linear Algebra professor to get his perspective on how I might have been able to solve this more efficiently somehow.
The goal is to map a point in
p (a square field of points (really also squares))
to the center of a cross in
c (a square field of crosses turned caddy-corner).
Graph paper and square counting led to the following table (where x is the row, y is the column and indices start at 1):
|side length of
|side length of
Those are some very easily predicted patterns and we can get the following information from them:
- the origin in
(1, 1)is mapped onto
(n + 1, 2)in
- the number of tiles required to map a
n * 3
By inspecting the graph, we can also see the following shifts:
(x + 1, y)corresponds to
(x + 2, y + 1). When you shift a square to the right in
p, the corresponding center square in
cis shifted to the right 2 and down 1 (In graphics, the vertival axis typically goes from top to bottom).
(x, y + 1)corresponds to
(x - 1, y + 2). Similar explanation to the above.
Now a formula can start to be derived. We can scale the shifts in
y by multiplying by a constant and to make it a real formula instead of just a correlation we simply add the offset from the orgin:
(x + dx, y + dy) -> (n + 1, 2) + dx(x + 2, y + 1) + dy(x -1, y + 2)
If we simply set
0, we end up with a formula for coordinates from the origin:
(dx, dy) -> (n + 1, 2) + dx(2, 1) + dy(-1, 2)
Finally, though I've been using indices starting at one, in programming we usually start indices at zero. It's a simple matter to subtract one from the origin part of the formula. In this final form, I'm also renaming
y because at this point they're offsets from the origin just like any other points.
(x, y) -> (n, 1) + x(2, 1) + y(-1, 2)
I'm pretty sure this generalizes to vector spaces of any dimensionality. To get from space
A to space
B, add the origin in
B to a constant times a whatever the unit vector in
A maps to in
B for each unit vector in A.
This is also the first time I've really used TypeScript. By opening the directory in VSCode and Running the build task once, I get compilation on save! NOTE: I'm putting all js/ts files in the ts/ folder. The js/ folder is a build artifact of the ts/ folder and I'm having git ignore it!