The Circle Behind the Sine

// cmd/wave/main.go — this chapter's bench

// eighth is the point standing k eighths of the way around a circle of
// radius 1, built out of chapter 24's arithmetic and nothing else. The
// four quarter points are written down because anyone can read them off
// a drawing; the four between them are the diagonal directions cut down
// to a length of one.
func eighth(k int) vec.Vec2 {
	pts := [8]vec.Vec2{
		{X: 1, Y: 0},
		vec.Vec2{X: 1, Y: 1}.Unit(),
		{X: 0, Y: 1},
		vec.Vec2{X: -1, Y: 1}.Unit(),
		{X: -1, Y: 0},
		vec.Vec2{X: -1, Y: -1}.Unit(),
		{X: 0, Y: -1},
		vec.Vec2{X: 1, Y: -1}.Unit(),
	}
	return pts[k%8]
}

// circle reads the two numbers off the point at each eighth of a turn.
// No trigonometry is used to produce this table: it is Unit, applied to
// four diagonals, and four corners nobody needs a method for.
func circle() {
	fmt.Println("a point walked round a circle of radius 1, an eighth of a turn at a time")
	fmt.Printf("  %8s %8s %10s %10s %12s\n", "eighths", "turn", "across", "up", "across²+up²")
	for k := 0; k <= 8; k++ {
		p := eighth(k)
		fmt.Printf("  %8d %8s %10.4f %10.4f %12.4f\n",
			k, fraction(k), p.X, p.Y, p.X*p.X+p.Y*p.Y)
	}
}

$ go run ./cmd/wave -mode circle
a point walked round a circle of radius 1, an eighth of a turn at a time
   eighths     turn     across         up  across²+up²
         0        0     1.0000     0.0000       1.0000
         1      1/8     0.7071     0.7071       1.0000
         2      1/4     0.0000     1.0000       1.0000
         3      3/8    -0.7071     0.7071       1.0000
         4      1/2    -1.0000     0.0000       1.0000
         5      5/8    -0.7071    -0.7071       1.0000
         6      3/4     0.0000    -1.0000       1.0000
         7      7/8     0.7071    -0.7071       1.0000
         8        1     1.0000     0.0000       1.0000

The last column is the guarantee that these eight points really are on the circle. A length is a square root of the two numbers each multiplied by itself and added, so a length of 1 means that sum is 1 with the root left off, and every row says 1.0000. The four diagonals came out right because Unit divides by whatever length it finds, and it never had to know that the length in question was 1.4142.

Now read the up column downward, which is the point of the whole table: 0, 0.7071, 1, 0.7071, 0, −0.7071, −1, −0.7071, 0. The steps between entries are not equal. Going from the start to an eighth of a turn lifts the point by 0.7071, and the next eighth lifts it by only 0.2929, even though the point walked exactly as far along the rim both times. That unevenness is the slowing near the top, and it arrives for free out of the geometry: near the top the point is mostly moving sideways, so very little of its travel counts as height.

The two columns have names, and they are the last two words of vocabulary this chapter introduces. The up reading is the sine of the amount turned. The across reading is the cosine. One point, one circle, two numbers read off it, and the across column is the same wave as the up column started two eighths earlier.

// cmd/wave/main.go

// rim measures how far it is around a circle of radius 1 without
// knowing the answer first. A square whose corners sit on the circle is
// too short; put a new corner between every pair, pushed out onto the
// circle, and it gets less too short. Doubling the corners is the whole
// method, and the only operations it uses are add, halve and Unit.
func rim() {
	corners := []vec.Vec2{{X: 1, Y: 0}, {X: 0, Y: 1}, {X: -1, Y: 0}, {X: 0, Y: -1}}
	fmt.Println("the way round a circle of radius 1, measured with straight lines")
	fmt.Printf("  %6s %14s %18s %16s\n", "sides", "one side", "all the way round", "half of it")
	for n := 4; n <= 1024; n *= 2 {
		side := corners[0].Sub(corners[1]).Len()
		p := float64(n) * side
		fmt.Printf("  %6d %14.9f %18.9f %16.9f\n", n, side, p, p/2)

		next := make([]vec.Vec2, 0, 2*n)
		for i := range corners {
			j := (i + 1) % len(corners)
			mid := corners[i].Add(corners[j]).Scale(0.5).Unit()
			next = append(next, corners[i], mid)
		}
		corners = next
	}
	fmt.Printf("  %6s %14s %18.9f %16.9f\n", "circle", "-", field.Turn, field.Turn/2)
}

$ go run ./cmd/wave -mode rim
the way round a circle of radius 1, measured with straight lines
   sides       one side  all the way round       half of it
       4    1.414213562        5.656854249      2.828427125
       8    0.765366865        6.122934918      3.061467459
      16    0.390180644        6.242890305      3.121445152
      32    0.196034281        6.273096981      3.136548491
      64    0.098135349        6.280662314      3.140331157
     128    0.049082457        6.282554502      3.141277251
     256    0.024543077        6.283027602      3.141513801
     512    0.012271769        6.283145881      3.141572940
    1024    0.006135914        6.283175451      3.141587725
  circle              -        6.283185307      3.141592654

The first row is the square, and its side is 1.414213562, the same number the eighth-turn point was found by dividing by. Each row after it doubles the corners and climbs a little, and the climbing slows because a shorter straight line hugs the curve more closely. By a thousand sides the figure is within a hundred-thousandth of the circle, and the digits that have stopped moving are 6.2831. Nothing anywhere in that loop knew the answer in advance.

The last row is the value Go carries, and the column beside it is the reason anyone has heard of any of this. Half the way round a circle of radius 1 is 3.141592653…, and that number has a name of its own, pi, written π. The whole way round is two of them. Go spells it math.Pi, and this book will spell one full turn field.Turn, since a turn is what the world's code actually means when it says it.

// cmd/wave/main.go

// agree checks the hand-built table against the two functions Go ships,
// once the turn is measured as rim walked.
func agree() {
	fmt.Println("the same eight points, asked for by rim walked instead of drawn")
	fmt.Printf("  %8s %10s %10s %11s %10s %11s\n",
		"eighths", "rim", "up", "math.Sin", "across", "math.Cos")
	for k := 0; k <= 8; k++ {
		p := eighth(k)
		r := float64(k) * field.Turn / 8
		fmt.Printf("  %8d %10.6f %10.6f %11.6f %10.6f %11.6f\n",
			k, r, p.Y, math.Sin(r), p.X, math.Cos(r))
	}
}

$ go run ./cmd/wave -mode agree
the same eight points, asked for by rim walked instead of drawn
   eighths        rim         up    math.Sin     across    math.Cos
         0   0.000000   0.000000    0.000000   1.000000    1.000000
         1   0.785398   0.707107    0.707107   0.707107    0.707107
         2   1.570796   1.000000    1.000000   0.000000    0.000000
         3   2.356194   0.707107    0.707107  -0.707107   -0.707107
         4   3.141593   0.000000    0.000000  -1.000000   -1.000000
         5   3.926991  -0.707107   -0.707107  -0.707107   -0.707107
         6   4.712389  -1.000000   -1.000000   0.000000   -0.000000
         7   5.497787  -0.707107   -0.707107   0.707107    0.707107
         8   6.283185   0.000000   -0.000000   1.000000    1.000000

Column three was drawn with a ruler and column four was computed by a library, and to six decimal places they are one column printed twice. That is the whole justification for using math.Sin: it is a fast way of asking what the circle would have said.

Two entries print -0.000000, at three quarters of a turn for the across and at a whole turn for the height, where the drawn point gives a clean 0.000000. Nothing is wrong. π never ends, so math.Pi is the nearest number a float64 can hold, and 6.283185307179586 is a hair under a true whole turn. The point is therefore a hair short of home, a hair below the axis, and the library reports that honestly as a height of about −0.00000000000000012. A comparison written as math.Sin(x) == 0 will be false at every angle that ought to give zero, which is the first thing to remember about asking a circle for exact numbers.

// internal/field/osc.go

// Turn is one whole trip around the circle, measured the way Go's
// math.Sin measures a turn: the distance walked around the rim of a
// circle of radius 1.
const Turn = 2 * math.Pi

// Osc is one thing that repeats: an angle that gains the same amount
// every tick, and three numbers that turn that angle into a
// displacement from wherever the thing rests.
type Osc struct {
	Amp   float64 // how far from the middle the swing reaches
	Rate  float64 // rim gained per tick
	Phase float64 // how far around the circle this one starts

	theta float64 // rim walked so far, before Phase is added
}

// Every is the rate that carries the angle once around the circle in n
// ticks, which is the knob anyone actually wants to set.
func Every(n float64) float64 { return Turn / n }

// Step advances the angle by one tick's worth. Nothing else moves.
func (o *Osc) Step() { o.theta += o.Rate }

// Angle is where on the rim this oscillator stands right now.
func (o *Osc) Angle() float64 { return o.theta + o.Phase }

// Value is the height of the point standing there, stretched to the
// amplitude: the displacement from the middle, this tick.
func (o *Osc) Value() float64 { return o.Amp * math.Sin(o.Angle()) }

// Across is the same point's sideways reading, on the same scale.
func (o *Osc) Across() float64 { return o.Amp * math.Cos(o.Angle()) }

$ go run ./cmd/wave -mode plot -period 20 -ticks 20
amplitude 6.00, 0.31416 rim a tick, phase 0.00000
  tick     angle     value   -10      -5         0         5        10
     0    0.0000    0.0000                       *
     1    0.3142    1.8541                       |   *
     2    0.6283    3.5267                       |      *
     3    0.9425    4.8541                       |         *
     4    1.2566    5.7063                       |          *
     5    1.5708    6.0000                       |           *
     6    1.8850    5.7063                       |          *
     7    2.1991    4.8541                       |         *
     8    2.5133    3.5267                       |      *
     9    2.8274    1.8541                       |   *
    10    3.1416    0.0000                       *
    11    3.4558   -1.8541                   *   |
    12    3.7699   -3.5267                *      |
    13    4.0841   -4.8541             *         |
    14    4.3982   -5.7063            *          |
    15    4.7124   -6.0000           *           |
    16    5.0265   -5.7063            *          |
    17    5.3407   -4.8541             *         |
    18    5.6549   -3.5267                *      |
    19    5.9690   -1.8541                   *   |
    20    6.2832   -0.0000                       *

The gutter is 41 columns wide at two columns to the pixel, so the asterisk is the float drawn on a line. Twenty ticks carry the angle from 0 to 6.2832, which the last section measured as exactly once round, and the wave closes: tick 20 is back where tick 0 was. One state variable did that, and one addition a tick maintained it.

The unevenness from the first table is now something to look at instead of read. Between ticks 0 and 1 the asterisk moves nearly two pixels; between ticks 4 and 5 it moves less than a third of one. The float slows as it nears the top, hangs, and gathers speed on the way down, and no code anywhere asked for that. It is what reading the height of a steadily walking point produces.

$ go run ./cmd/wave -mode plot -period 20 -amp 10 -ticks 10
amplitude 10.00, 0.31416 rim a tick, phase 0.00000
  tick     angle     value   -10      -5         0         5        10
     0    0.0000    0.0000                       *
     1    0.3142    3.0902                       |     *
     2    0.6283    5.8779                       |           *
     3    0.9425    8.0902                       |               *
     4    1.2566    9.5106                       |                  *
     5    1.5708   10.0000                       |                   *
     6    1.8850    9.5106                       |                  *
     7    2.1991    8.0902                       |               *
     8    2.5133    5.8779                       |           *
     9    2.8274    3.0902                       |     *
    10    3.1416    0.0000                       *

$ go run ./cmd/wave -mode plot -period 8 -ticks 16
amplitude 6.00, 0.78540 rim a tick, phase 0.00000
  tick     angle     value   -10      -5         0         5        10
     0    0.0000    0.0000                       *
     1    0.7854    4.2426                       |       *
     2    1.5708    6.0000                       |           *
     3    2.3562    4.2426                       |       *
     4    3.1416    0.0000                       *
     5    3.9270   -4.2426               *       |
     6    4.7124   -6.0000           *           |
     7    5.4978   -4.2426               *       |
     8    6.2832   -0.0000                       *
     9    7.0686    4.2426                       |       *
    10    7.8540    6.0000                       |           *
    11    8.6394    4.2426                       |       *
    12    9.4248    0.0000                       *
    13   10.2102   -4.2426               *       |
    14   10.9956   -6.0000           *           |
    15   11.7810   -4.2426               *       |
    16   12.5664    0.0000                       *

$ go run ./cmd/wave -mode plot -period 20 -phase 0.25 -ticks 10
amplitude 6.00, 0.31416 rim a tick, phase 1.57080
  tick     angle     value   -10      -5         0         5        10
     0    1.5708    6.0000                       |           *
     1    1.8850    5.7063                       |          *
     2    2.1991    4.8541                       |         *
     3    2.5133    3.5267                       |      *
     4    2.8274    1.8541                       |   *
     5    3.1416    0.0000                       *
     6    3.4558   -1.8541                   *   |
     7    3.7699   -3.5267                *      |
     8    4.0841   -4.8541             *         |
     9    4.3982   -5.7063            *          |
    10    4.7124   -6.0000           *           |

Amplitude first. Every value in the second run is the matching value of the first multiplied by 10/6, and the angle column is untouched, because scaling happens after the reading is taken. The wave is wider and its timing is identical: the peak still lands on tick 5.

The period run changes the timing and nothing else. Eight ticks to a turn means the angle gains 0.78540 a tick, which the interlude names as π/4, so every tick lands on an eighth-turn mark and the value column holds nothing but 0, 4.2426 and 6. Those middle entries are 6 × 0.7071, and they print the same digits as the length chapter 24 squeezed out for a step of 3 across and 3 down, since both are three times 1.41421.

Phase moves the starting place round the circle without touching the speed. A quarter turn of head start is 1.57080 of rim, so the run opens at the top of the ride instead of the middle of it, and from there it is the baseline wave with its first five ticks cut off. Two floats with the same amplitude and rate and different phases are one motion observed at two moments, and that is all it takes to stop a row of them moving as a block.

// cmd/worldc/main.go

// Float is one thing riding the surface of the pool: the place it would
// sit on still water, and the oscillation that lifts it off that place.
type Float struct {
	Rest field.Vec2
	Bob  field.Osc
}

// Screen is where this float is drawn, in world pixels. The value is a
// height, and a screen counts Y downward, so a lift of five pixels is
// five pixels of smaller Y.
func (f *Float) Screen() (int, int) {
	return int(math.Round(f.Rest.X)), int(math.Round(f.Rest.Y - f.Bob.Value()))
}

// timber is the colour a float is painted in, palette entry 14.
const timber render.Color = 0xFFC75938

// raft paints a four-by-two plank at a float's current place.
func raft(b *render.Buffer, cam render.Camera, f *Float) {
	wx, wy := f.Screen()
	sx, sy := cam.ToScreen(wx, wy)
	b.FillRect(render.Rect{X0: sx - 2, Y0: sy - 1, X1: sx + 2, Y1: sy + 1}, timber)
}

// cmd/worldc/main.go — placing them, and the loop

	floats := make([]Float, n)
	for i := range floats {
		floats[i] = Float{
			Rest: field.Vec2{X: 44 + float64(i)*32, Y: 72},
			Bob: field.Osc{
				Amp:   amp,
				Rate:  rate,
				Phase: spread * float64(i) * field.Turn,
			},
		}
	}

	for t := 0; t <= ticks; t++ {
		if t > 0 {
			for i := range floats {
				floats[i].Bob.Step() // the whole of this chapter, once a tick
			}
		}
		b.Fill(render.Void)
		render.DrawMapVia(b, tiles, a.tiles, cam)
		for i := range floats {
			raft(b, cam, &floats[i])
		}
		h := b.Hash()
		...
	}

$ go run ./cmd/worldc -bob -ticks 40
bob: 3 floats on the pool of seed 5, amplitude 5.00 pixels, one turn every 40 ticks (4.0 seconds)
     the angle gains 0.15708 rim a tick; phases 0.0000 0.0000 0.0000
  tick     angle   lift A   row   lift B   row   lift C   row  frame
     0    0.0000     0.00    72     0.00    72     0.00    72  faa668b96e47bb3c
     5    0.7854     3.54    68     3.54    68     3.54    68  f7f2a5cdaaf6df4d
    10    1.5708     5.00    67     5.00    67     5.00    67  2d5d7d1e364c2557
    15    2.3562     3.54    68     3.54    68     3.54    68  f7f2a5cdaaf6df4d
    20    3.1416     0.00    72     0.00    72     0.00    72  faa668b96e47bb3c
    25    3.9270    -3.54    76    -3.54    76    -3.54    76  61088d1046bf7ed7
    30    4.7124    -5.00    77    -5.00    77    -5.00    77  d78009c5b62a9116
    35    5.4978    -3.54    76    -3.54    76    -3.54    76  61088d1046bf7ed7
    40    6.2832    -0.00    72    -0.00    72    -0.00    72  faa668b96e47bb3c
  float A's angle after 40 ticks is 6.2831853071795862, and one whole turn is 6.2831853071795862

Nothing in that run reads a random number, and the run says so by repeating itself. The frame at tick 40 hashes to faa668b96e47bb3c, which is the frame at tick 20 and the frame at tick 0; ticks 5 and 15 pair off the same way, and so do ticks 25 and 35. A picture drawn from a seeded stream needs the seed quoted beside it before a hash means anything; the only seed here made the ground, which never moves, so any machine running this command prints these nine hashes.

The last line is the reason ticks 0 and 40 agree so exactly. Forty additions of field.Turn/40 landed on 6.2831853071795862, digit for digit the same float64 as one whole turn, so tick 40 really is the start again. The lift prints -0.00 there rather than 0.00 because math.Sin of that value is a hair under zero, as the agreement table warned, and a fifteenth-decimal-place hair rounds to the same row 72 that tick 0 drew.

The row column also shows what rounding does to a small ride. A lift of 3.54 puts the float at 68.46, which rounds to 68, and a lift of −3.54 puts it at 75.54, which rounds to 76. The two are not the same distance from 72 on the screen even though they are the same distance in the numbers, and that asymmetry is unavoidable when a five pixel ride is drawn on whole pixels. The number kept in the float is the exact one.

$ go run ./cmd/worldc -bob -ticks 40 -spread 0.25
bob: 3 floats on the pool of seed 5, amplitude 5.00 pixels, one turn every 40 ticks (4.0 seconds)
     the angle gains 0.15708 rim a tick; phases 0.0000 1.5708 3.1416
  tick     angle   lift A   row   lift B   row   lift C   row  frame
     0    0.0000     0.00    72     5.00    67     0.00    72  d71db1cdf6110768
     5    0.7854     3.54    68     3.54    68    -3.54    76  23e0058009f440da
    10    1.5708     5.00    67     0.00    72    -5.00    77  3620fd53aebe0753
    15    2.3562     3.54    68    -3.54    76    -3.54    76  64950c6ab377c26f
    20    3.1416     0.00    72    -5.00    77    -0.00    72  7c4e100493766fc1
    25    3.9270    -3.54    76    -3.54    76     3.54    68  5abaeced5fa93b8d
    30    4.7124    -5.00    77    -0.00    72     5.00    67  83a944b1978f7845
    35    5.4978    -3.54    76     3.54    68     3.54    68  9d378973add961ff
    40    6.2832    -0.00    72     5.00    67     0.00    72  d71db1cdf6110768
  float A's angle after 40 ticks is 6.2831853071795862, and one whole turn is 6.2831853071795862

-spread 0.25 gives float B a quarter turn of head start and float C a half turn, and the pool stops looking like a lift. Watch B's column against A's: B is doing at tick 0 what A does at tick 10, and at tick 25 what A does at tick 35. C is half a turn round, so it is at the bottom whenever A is at the top. Eight distinct hashes now instead of five, and the run still closes on itself at tick 40, because a head start added once never changes how long a lap takes.