carray-jit 0.1.0

data/examples/applications/game_of_life.rb

@@ -0,0 +1,161 @@
+# Conway's Game of Life
+#
+# A generation is a stencil: nine reads and two comparisons per cell.  Written
+# with CArray's operators it would be eight shifted arrays added together, and
+# eight passes over the board to do it; written as a Ruby loop it would be a
+# block call per cell.  Written here it is the rule as it is stated, run once
+# per cell.
+#
+# It is written twice.  With the indices named the extents say which cells are
+# written, and the border is what they leave out -- the board has edges, and a
+# glider that reaches one dies there.  With windows the border is an argument
+# instead, and `border: :wrap` is what makes the board the torus the rules are
+# usually stated on.
+#
+#   ruby examples/applications/game_of_life.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+ROWS, COLUMNS = 24, 48
+
+def step (current, following)
+  rows, columns = current.dim
+  CArray.jit_for(1...(rows-1), 1...(columns-1)) { |i, j|
+    neighbours = current[i-1, j-1] + current[i-1, j] + current[i-1, j+1] +
+                 current[i,   j-1] +                   current[i,   j+1] +
+                 current[i+1, j-1] + current[i+1, j] + current[i+1, j+1]
+    if neighbours == 3
+      following[i, j] = 1
+    elsif neighbours == 2
+      following[i, j] = current[i, j]
+    else
+      following[i, j] = 0
+    end
+  }
+end
+
+# The same rule with windows onto the board instead of indices.  `a[0, 0]` is
+# the cell, `a[-1, -1]` its neighbour, and the block's value is what the cell
+# gets -- so the rule is an expression, and there is no loop and no extent to
+# write.  `border: :wrap` says that a read off one edge comes back the other
+# side, which is the whole of what makes this a torus.
+def step_torus (current, following)
+  CArray.jit_stencil(current, border: :wrap, into: following) { |a|
+    neighbours = a[-1, -1] + a[-1, 0] + a[-1, 1] +
+                 a[0,  -1] +            a[0,  1] +
+                 a[1,  -1] + a[1,  0] + a[1,  1]
+    neighbours == 3 ? 1 : (neighbours == 2 ? a[0, 0] : 0)
+  }
+end
+
+def draw (board, title)
+  puts title
+  board.to_a.each { |row| puts "  " + row.map { |cell| cell == 1 ? "#" : "·" }.join }
+end
+
+board = CArray.int32(ROWS, COLUMNS)
+scratch = CArray.int32(ROWS, COLUMNS)
+
+# A glider, and an r-pentomino to make a mess of things.
+[[2,2],[3,3],[4,1],[4,2],[4,3]].each { |i, j| board[i, j] = 1 }
+[[12,20],[12,21],[13,19],[13,20],[14,20]].each { |i, j| board[i, j] = 1 }
+
+draw(board, "generation 0")
+
+64.times do |generation|
+  step(board, scratch)
+  board, scratch = scratch, board
+  draw(board, "generation #{generation + 1}") if generation + 1 == 16 ||
+                                                 generation + 1 == 32
+end
+
+# The glider has walked down and to the right; the r-pentomino has burned
+# itself out against the edge.  The board is a torus in the usual statement of
+# the rules -- here the border is simply not written, which is what the extents
+# say, and nothing else in the program had to know it.
+
+# Away from the edges the two spellings are the same rule, and agree on it.
+sample = CArray.int32(ROWS, COLUMNS)
+[[5,5],[5,6],[5,7],[6,4],[6,5],[6,6],[9,20],[10,21],[11,19],[11,20],[11,21]].each { |i, j|
+  sample[i, j] = 1
+}
+by_index = CArray.int32(ROWS, COLUMNS)
+by_window = CArray.int32(ROWS, COLUMNS)
+step(sample, by_index)
+step_torus(sample, by_window)
+interior = [1...(ROWS-1), 1...(COLUMNS-1)]
+puts
+puts "the two spellings, on the interior: " \
+     "#{by_index[*interior].to_a == by_window[*interior].to_a}"
+
+# On the torus the glider does not run out of board.  A small one, so that it
+# reaches the corner while there is still something to watch.
+SIDE = 16
+torus = CArray.int32(SIDE, SIDE)
+spare = CArray.int32(SIDE, SIDE)
+[[1,2],[2,3],[3,1],[3,2],[3,3]].each { |i, j| torus[i, j] = 1 }
+started_from = torus.copy               # `to_ca` would answer this same array
+
+draw(torus, "torus, generation 0")
+64.times do |generation|
+  step_torus(torus, spare)
+  torus, spare = spare, torus
+  draw(torus, "torus, generation #{generation + 1}") if generation + 1 == 52 ||
+                                                        generation + 1 == 64
+end
+
+# It left by the bottom right and came back at the top left, unchanged: a
+# glider on a torus of side 16 is back where it started after 64 generations,
+# which is the check on `:wrap` -- the board has no edge for it to die on.
+puts "  the glider came home:            #{torus.to_a == started_from.to_a}"
+
+# How long a generation takes, against the same rule as a Ruby loop.
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+100.times { step(board, scratch); board, scratch = scratch, board }
+compiled = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 100
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+5.times do
+  (1...(ROWS-1)).each do |i|
+    (1...(COLUMNS-1)).each do |j|
+      neighbours = board[i-1, j-1] + board[i-1, j] + board[i-1, j+1] +
+                   board[i,   j-1] +                 board[i,   j+1] +
+                   board[i+1, j-1] + board[i+1, j] + board[i+1, j+1]
+      scratch[i, j] = neighbours == 3 ? 1 : (neighbours == 2 ? board[i, j] : 0)
+    end
+  end
+end
+interpreted = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 5
+
+step_torus(board, scratch)              # compiled once, then measured
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+100.times { step_torus(board, scratch); board, scratch = scratch, board }
+wrapped = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 100
+
+puts format("a generation: %.3f ms with the indices named, %.3f ms as a window " \
+            "on a torus, %.3f ms in Ruby (%.0fx)",
+            compiled * 1e3, wrapped * 1e3, interpreted * 1e3, interpreted / compiled)
+
+# The window is not the slower rule; this board is small.  Its frame is a
+# tenth of its cells, and the frame is where the wrap is woven into the reads
+# -- and a generation here is measured in tens of microseconds, so the cost of
+# making the call at all is in the number too.  On a board where neither is
+# true the two are level:
+LARGE = 1200
+crowd = CArray.int32(LARGE, LARGE).random!(2)
+next_crowd = CArray.int32(LARGE, LARGE)
+step(crowd, next_crowd)
+step_torus(crowd, next_crowd)
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+10.times { step(crowd, next_crowd) }
+large_indexed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 10
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+10.times { step_torus(crowd, next_crowd) }
+large_wrapped = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 10
+
+puts format("a generation on %d x %d: %.2f ms with the indices named, " \
+            "%.2f ms as a window on a torus",
+            LARGE, LARGE, large_indexed * 1e3, large_wrapped * 1e3)

data/examples/applications/heat_equation.rb

@@ -0,0 +1,117 @@
+# Heat diffusion in a rod, solved implicitly
+#
+# The explicit scheme is a stencil and is easy; it is also unstable unless the
+# time step is tiny.  The implicit one is stable at any step, at the price of
+# solving a tridiagonal system every step -- and that solver is two sequential
+# sweeps, which is exactly what an array library cannot vectorise for you.
+#
+# So this is the shape a lot of numerical code has: an outer loop in Ruby, and
+# per step a couple of kernels that do the work.
+#
+#   ruby examples/applications/heat_equation.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+n = 400            # points along the rod
+steps = 2_000
+dx = 1.0 / (n - 1)
+dt = 2.5e-5        # eight times the step an explicit scheme would survive
+r = dt / (dx * dx)
+
+temperature = CArray.double(n)
+# A hot band in the middle of a cold rod, ends held at zero.
+CArray.jit_for(n) { |i| temperature[i] = 0.0 }
+(n * 4 / 10...(n * 6 / 10)).each { |i| temperature[i] = 1.0 }
+
+initial_heat = temperature.sum * dx
+
+# Backward Euler: (1 + 2r) T[i] - r T[i-1] - r T[i+1] = T_old[i], which is
+# tridiagonal with constant coefficients.
+lower = -r
+diagonal = 1.0 + 2.0 * r
+upper = -r
+
+cc = CArray.double(n)
+dd = CArray.double(n)
+
+def solve (temperature, cc, dd, lower, diagonal, upper, n)
+  cc[0] = 0.0                      # boundary: T[0] fixed
+  dd[0] = temperature[0]
+
+  CArray.jit_for(1...n) { |i|     # forward sweep
+    denominator = diagonal - lower * cc[i-1]
+    cc[i] = upper / denominator
+    dd[i] = (temperature[i] - lower * dd[i-1]) / denominator
+  }
+
+  # boundary: T[n-1] fixed
+  dd[n-1] = temperature[n-1]
+  temperature[n-1] = dd[n-1]
+
+  CArray.jit_for((n-2).step(0, -1)) { |i|   # back substitution
+    temperature[i] = dd[i] - cc[i] * temperature[i+1]
+  }
+end
+
+def draw (temperature, label)
+  n = temperature.dim[0]
+  row = (0...72).map { |k|
+    value = temperature[k * (n - 1) / 71]
+    " .:-=+*#@"[[(value * 8).round, 8].min] || " "
+  }
+  puts "  #{label.rjust(6)} |#{row.join}|"
+end
+
+puts "rod of #{n} points, #{steps} implicit steps of dt = #{format('%.1e', dt)}"
+puts format("  an explicit scheme would need dt < %.1e here", dx * dx / 2)
+draw(temperature, "0")
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+steps.times do |step|
+  solve(temperature, cc, dd, lower, diagonal, upper, n)
+  draw(temperature, (step + 1).to_s) if [50, 200, 800, 2000].include?(step + 1)
+end
+elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+
+puts format("  %.0f ms for %d steps -- %.1f us per solve of %d unknowns",
+            elapsed * 1e3, steps, elapsed / steps * 1e6, n)
+
+# The same solve written as Ruby loops, for comparison.  At n = 400 a fair
+# part of the compiled time is the two kernel calls rather than the arithmetic
+# in them, so this is the regime where the gap is smallest -- and it is still
+# worth having.
+def ruby_solve (temperature, cc, dd, lower, diagonal, upper, n)
+  cc[0] = 0.0
+  dd[0] = temperature[0]
+  (1...n).each do |i|
+    denominator = diagonal - lower * cc[i-1]
+    cc[i] = upper / denominator
+    dd[i] = (temperature[i] - lower * dd[i-1]) / denominator
+  end
+  dd[n-1] = temperature[n-1]
+  temperature[n-1] = dd[n-1]
+  (n-2).step(0, -1) do |i|
+    temperature[i] = dd[i] - cc[i] * temperature[i+1]
+  end
+end
+
+def time (repeats)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  repeats.times { yield }
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / repeats
+end
+
+[400, 4_000, 40_000].each do |size|
+  field = CArray.double(size).seq! { |i| i.to_f / size }
+  work = [CArray.double(size), CArray.double(size)]
+  compiled = time(20) { solve(field, *work, lower, diagonal, upper, size) }
+  interpreted = time(3) { ruby_solve(field, *work, lower, diagonal, upper, size) }
+  puts format("  n = %6d   %7.1f us compiled   %8.1f us Ruby   %3.0fx",
+              size, compiled * 1e6, interpreted * 1e6, interpreted / compiled)
+end
+
+# Heat leaves through the ends, so the total falls; what it must not do is
+# oscillate or blow up, which is the whole reason for solving implicitly.
+puts format("  heat: %.4f initially, %.4f now, peak temperature %.4f",
+            initial_heat, temperature.sum * dx, temperature.max)

data/examples/applications/kepler.rb

@@ -0,0 +1,178 @@
+# Kepler's equation, by Newton's method.
+#
+#   M = E - e sin E
+#
+# Given the mean anomaly M of a body on an ellipse, the eccentric anomaly E is
+# what the equation has to be solved for, and there is no closed form.  Newton
+# converges in a handful of passes -- but not the same handful for every cell:
+# near e = 1 and M = 0 the correction is small and the iteration crawls, while
+# a nearly circular orbit is done in two.
+#
+# So the number of passes is a property of the cell, not of the program, and
+# that is what `while` is for.  A cap in an extent would be the wrong shape
+# here: it would have to be the worst cell's count, and every other cell would
+# be written to iterate as long as the worst one.
+#
+#   ruby examples/applications/kepler.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+n = 200_000
+tolerance = 1e-13
+
+mean_anomaly = CArray.double(n) { |i| 2.0 * Math::PI * i / n - Math::PI }
+
+def solve (mean_anomaly, eccentricity, tolerance)
+  eccentric = CArray.double(mean_anomaly.elements)
+  CArray.jit_for(mean_anomaly.elements) { |i|
+    guess = mean_anomaly[i]                     # good enough for any e < 1
+    step = 1.0
+    # The condition is read at the top of every pass, as Ruby's is, so `step`
+    # has to be a local before the loop -- a name the body alone assigned
+    # would not be in scope where the condition wants it.
+    while step.abs > tolerance
+      step = (guess - eccentricity * Math.sin(guess) - mean_anomaly[i]) /
+             (1.0 - eccentricity * Math.cos(guess))
+      guess = guess - step
+    end
+    eccentric[i] = guess
+  }
+  eccentric
+end
+
+puts "Kepler's equation over #{n} anomalies"
+[0.0167, 0.2056, 0.6, 0.9].each do |eccentricity|
+  eccentric = solve(mean_anomaly, eccentricity, tolerance)
+  # The check is the equation itself: put E back and see whether M comes out.
+  residual = (eccentric - eccentricity * eccentric.sin - mean_anomaly).abs.max
+  puts format("  e = %.4f   largest residual %.2e", eccentricity, residual)
+end
+
+# How many passes each cell took, which is the thing the extent could not have
+# known.  Counting is a second local; the loop is otherwise the same.
+eccentricity = 0.9
+passes = CArray.int32(n)
+roots = CArray.double(n)
+CArray.jit_for(n) { |i|
+  guess = mean_anomaly[i]
+  step = 1.0
+  taken = 0
+  while step.abs > tolerance
+    step = (guess - eccentricity * Math.sin(guess) - mean_anomaly[i]) /
+           (1.0 - eccentricity * Math.cos(guess))
+    guess = guess - step
+    taken = taken + 1
+  end
+  roots[i] = guess
+  passes[i] = taken
+}
+
+puts
+puts "at e = 0.9"
+puts "  passes                 #{passes.min}..#{passes.max}, #{format('%.2f', passes.sum.to_f / n)} on average"
+puts "  the slowest cell is    M = #{format('%.4f', mean_anomaly[passes.max_addr])}"
+puts "  a cap in an extent     would have been #{passes.max} for every cell"
+
+# The same loop written in Ruby.  A `while` in the kernel is Ruby's `while`:
+# the condition is read at the top of every pass, `step` is a local before the
+# loop, and no accumulation is reassociated -- so the two take the same passes
+# over the same arithmetic.
+in_ruby = CArray.double(n)
+(0...n).each do |i|
+  guess = mean_anomaly[i]
+  step = 1.0
+  while step.abs > tolerance
+    step = (guess - eccentricity * Math.sin(guess) - mean_anomaly[i]) /
+           (1.0 - eccentricity * Math.cos(guess))
+    guess = guess - step
+  end
+  in_ruby[i] = guess
+end
+
+# What they do not share is the sine.  A few hundred cells come out a bit
+# apart, and it is worth finding where that comes from before blaming the
+# loop, because it is not the loop: the kernel asks for the sine and the
+# cosine of the same argument in the same pass, and the C compiler answers
+# both with one call to the library's `sincos`, which rounds a few arguments
+# differently from `sin` on its own.  Ruby calls `sin`.
+differing = (0...n).count { |i| roots[i] != in_ruby[i] }
+
+iterate = CArray.double(n)                    # one Newton step, in Ruby
+(0...n).each do |i|
+  guess = mean_anomaly[i]
+  iterate[i] = guess - (guess - eccentricity * Math.sin(guess) - mean_anomaly[i]) /
+                       (1.0 - eccentricity * Math.cos(guess))
+end
+
+alone = CArray.double(n)
+CArray.jit_for(n) { |i| alone[i] = Math.sin(iterate[i]) }
+together = CArray.double(n)
+unused = CArray.double(n)
+CArray.jit_for(n) { |i|
+  together[i] = Math.sin(iterate[i])
+  unused[i] = Math.cos(iterate[i])
+}
+
+puts format("  differs from Ruby      %d of %d cells, largest %.1e",
+            differing, n, (roots - in_ruby).abs.max)
+puts format("  a sine on its own      differs from Ruby's for %d arguments",
+            (0...n).count { |i| alone[i] != Math.sin(iterate[i]) })
+puts format("  a sine beside a cosine differs for %d of the same arguments",
+            (0...n).count { |i| together[i] != Math.sin(iterate[i]) })
+
+# With no transcendental in it, the same Newton iteration agrees bit for bit
+# -- a cube root, written the same way, over the same anomalies:
+cube = CArray.double(n)
+CArray.jit_for(n) { |i|
+  x = 1.0 + mean_anomaly[i].abs
+  step = 1.0
+  while step.abs > 1e-14 * x
+    step = (x * x * x - (1.0 + mean_anomaly[i].abs)) / (3.0 * x * x)
+    x = x - step
+  end
+  cube[i] = x
+}
+cube_in_ruby = CArray.double(n)
+(0...n).each do |i|
+  a = 1.0 + mean_anomaly[i].abs
+  x = a
+  step = 1.0
+  while step.abs > 1e-14 * x
+    step = (x * x * x - a) / (3.0 * x * x)
+    x = x - step
+  end
+  cube_in_ruby[i] = x
+end
+puts "  a cube root by the same loop, bit for bit: #{cube.to_a == cube_in_ruby.to_a}"
+
+# What it cost each way.  The kernel is compiled on its first call and cached,
+# so the one above is what paid for it.
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+5.times { solve(mean_anomaly, eccentricity, tolerance) }
+compiled = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 5
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+(0...n).each do |i|
+  guess = mean_anomaly[i]
+  step = 1.0
+  while step.abs > tolerance
+    step = (guess - eccentricity * Math.sin(guess) - mean_anomaly[i]) /
+           (1.0 - eccentricity * Math.cos(guess))
+    guess = guess - step
+  end
+  in_ruby[i] = guess
+end
+interpreted = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+
+puts
+puts format("  %.2f ms compiled, %.2f ms in Ruby (%.0fx)",
+            compiled * 1e3, interpreted * 1e3, interpreted / compiled)
+
+# What `while` gives up is the guarantee that the loop ends.  Newton on this
+# equation converges for every e < 1 from this starting guess, which is why it
+# is written this way here; a solver for an equation with no such argument
+# behind it wants the bounded spelling, where the extent holds the cap and a
+# cell that ran out can be told from one that converged.  A kernel that does
+# not return cannot be interrupted -- Ctrl-C is not delivered until the call
+# comes back.

data/examples/applications/mandelbrot.rb

@@ -0,0 +1,151 @@
+# The Mandelbrot set, as an escape-time count.
+#
+# Every cell iterates z = z*z + c until |z| passes 2, and how many passes that
+# took is what is drawn.  The number of passes is different for every cell and
+# is not known before the loop runs, which is what `while` is for; the bail-out
+# count is a cap on it, so this is written as an inner loop with a `break`,
+# and the same thing with `while` is measured beside it.
+#
+# Written over whole arrays this would be one pass per iteration over the
+# entire plane, with every cell paying for the deepest one.  Here each cell
+# stops when it escapes.
+#
+# Three spellings of the same set are here: the bounded inner loop, the same
+# thing with `while`, and the iteration written in one variable with a Complex
+# local, which is what z = z*z + c says.
+#
+#   ruby examples/applications/mandelbrot.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+ROWS, COLUMNS = 36, 96
+LIMIT = 500
+
+# The window on the plane: the whole set, squashed to fit a terminal.
+x0, x1 = -2.2, 0.8
+y0, y1 = -1.25, 1.25
+
+counts = CArray.int32(ROWS, COLUMNS)
+
+escape = lambda do
+  CArray.jit_for(ROWS, COLUMNS) { |i, j|
+    cx = x0 + (x1 - x0) * j / (COLUMNS - 1.0)
+    cy = y0 + (y1 - y0) * i / (ROWS - 1.0)
+    zx = 0.0
+    zy = 0.0
+    taken = 0
+    (0...LIMIT).each { |k|
+      break if zx * zx + zy * zy > 4.0
+      next_zx = zx * zx - zy * zy + cx      # a kernel assigns one name at a time
+      zy = 2.0 * zx * zy + cy
+      zx = next_zx
+      taken = taken + 1
+    }
+    counts[i, j] = taken
+  }
+end
+
+escape.call
+
+# LIMIT passes without escaping is taken for a point of the set.
+SHADES = " .:-=+*#%"
+puts "the set, by escape time"
+counts.to_a.each do |row|
+  puts "  " + row.map { |count|
+    next "@" if count == LIMIT
+    step = Math.log(count + 1) / Math.log(LIMIT + 1) * SHADES.size
+    SHADES[[step.to_i, SHADES.size - 1].min]
+  }.join
+end
+
+inside = counts.eq(LIMIT).count(1)
+puts format("  %d of %d cells never escaped", inside, ROWS * COLUMNS)
+
+# The same iteration written with `while`, which is what it would be if there
+# were no cap to put in an extent.  It gives the same counts; what it gives up
+# is the guarantee that the loop ends, which here is exactly what the cap was
+# providing -- a cell inside the set does not escape, ever, so the `while`
+# needs the count in its condition to stop at all.
+by_while = CArray.int32(ROWS, COLUMNS)
+CArray.jit_for(ROWS, COLUMNS) { |i, j|
+  cx = x0 + (x1 - x0) * j / (COLUMNS - 1.0)
+  cy = y0 + (y1 - y0) * i / (ROWS - 1.0)
+  zx = 0.0
+  zy = 0.0
+  taken = 0
+  while zx * zx + zy * zy <= 4.0 && taken < LIMIT
+    next_zx = zx * zx - zy * zy + cx
+    zy = 2.0 * zx * zy + cy
+    zx = next_zx
+    taken = taken + 1
+  end
+  by_while[i, j] = taken
+}
+puts "  while agrees with the bounded loop: #{by_while.to_a == counts.to_a}"
+
+# ------------------------------------------------------- and in one variable
+
+# The iteration is z = z*z + c, and a kernel can say that.  A Complex local
+# is a `double _Complex` in the generated C, so the two reals above collapse
+# into one name and the temporary they needed goes away -- `z = z * z + c` is
+# a single assignment, and multiplication is the one Ruby's Complex does.
+#
+# `Complex(x, y)` is the way in from two reals, `abs` one of the ways back
+# out.  Ordering is refused on a Complex, as Ruby refuses it, so the test is
+# on `abs` -- and `abs > 2.0` is the same test as `zx*zx + zy*zy > 4.0`, a
+# square root apart.
+complex_counts = CArray.int32(ROWS, COLUMNS)
+
+complex_escape = lambda do
+  CArray.jit_for(ROWS, COLUMNS) { |i, j|
+    c = Complex(x0 + (x1 - x0) * j / (COLUMNS - 1.0),
+                y0 + (y1 - y0) * i / (ROWS - 1.0))
+    z = Complex(0.0, 0.0)
+    taken = 0
+    (0...LIMIT).each { |k|
+      break if z.abs > 2.0
+      z = z * z + c
+      taken = taken + 1
+    }
+    complex_counts[i, j] = taken
+  }
+end
+
+complex_escape.call
+puts "  the Complex spelling agrees:        #{complex_counts.to_a == counts.to_a}"
+
+# It costs a square root the real spelling did not pay -- `abs` is `cabs`,
+# where the two reals compared a sum of squares against four -- and the frame
+# below says how much that is, which on this machine is nothing worth
+# choosing between.  A kernel that wanted the other test back would write
+# `(z * z.conjugate).real > 4.0`: the same arithmetic, in one name.
+complex_started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+10.times { complex_escape.call }
+complex_timed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - complex_started) / 10
+
+# What it would have cost in Ruby.
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+10.times { escape.call }
+compiled = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 10
+
+started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+(0...ROWS).each do |i|
+  (0...COLUMNS).each do |j|
+    cx = x0 + (x1 - x0) * j / (COLUMNS - 1.0)
+    cy = y0 + (y1 - y0) * i / (ROWS - 1.0)
+    zx = zy = 0.0
+    taken = 0
+    LIMIT.times do
+      break if zx * zx + zy * zy > 4.0
+      zx, zy = zx * zx - zy * zy + cx, 2.0 * zx * zy + cy
+      taken += 1
+    end
+    by_while[i, j] = taken
+  end
+end
+interpreted = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+
+puts format("  one frame: %.2f ms compiled, %.2f ms as a Complex, %.2f ms in Ruby (%.0fx)",
+            compiled * 1e3, complex_timed * 1e3, interpreted * 1e3,
+            interpreted / compiled)