carray-jit 0.1.2 → 0.1.3

data/examples/applications/lookup.rb

@@ -0,0 +1,126 @@
+# Half a million queries against an uneven grid.
+#
+# Tabulated data rarely comes on a regular grid -- a sounding is dense near
+# the ground, a spectrum near a line -- so reading a value off it means
+# finding which two samples a query falls between, and that is a search per
+# query.  The loop is short, about `log n` steps, but where it looks is
+# different for every cell, which is the part an expression over whole arrays
+# cannot express: it has no way to say "this cell reads knots[lo] where lo is
+# what this cell just worked out".
+#
+# CArray can still do it, by materialising the answer to the search as an
+# index array and gathering through it, and that is measured here beside the
+# kernel.  The two agree to the bit; what differs is how many passes and how
+# much scratch it took -- and, in the search itself, what may be assumed
+# about the grid.
+#
+#   ruby examples/applications/lookup.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+N = 2_000                               # samples in the table
+Q = 500_000                             # queries against it
+
+# A grid that crowds towards zero, and a function sampled on it.
+knots = (CArray.double(N).seq!(0, 1.0 / (N - 1)) ** 2) * 100
+table = knots.sin
+query = CArray.double(Q).seq!(0, 99.9 / Q)
+
+# The search and the interpolation in one pass.  `lo` and `hi` are the cell's
+# own, so the kernel reads `knots[lo]` at an address no other cell shares --
+# a gather, written as the subscript it is.
+def interpolate (knots, table, query)
+  n = knots.elements
+  out = CArray.double(query.elements)
+  CArray.jit_for(query.elements) { |i|
+    t = query[i]
+    lo = 0
+    hi = n - 1
+    while hi - lo > 1
+      mid = (lo + hi) / 2
+      if knots[mid] > t
+        hi = mid
+      else
+        lo = mid
+      end
+    end
+    weight = (t - knots[lo]) / (knots[lo + 1] - knots[lo])
+    out[i] = table[lo] * (1.0 - weight) + table[lo + 1] * weight
+  }
+  out
+end
+
+# The same answer over whole arrays.  `search_nearest` is CArray's own and is
+# not a loop in Ruby -- but it answers with the nearest sample rather than the
+# one below, so the bracket has to be fixed up, and every step from here on is
+# another pass and another array the size of the queries.
+#
+# It is also the slowest line here, and that is a contract rather than a
+# fault: nothing says a CArray is sorted, so `search_nearest` looks at every
+# sample for every query.  A kernel is where the grid being monotonic can be
+# used, because the search is written rather than called.
+def interpolate_over_arrays (knots, table, query)
+  near = knots.search_nearest(query)
+  lo = near.to_ca
+  lo[knots[near].gt(query)] -= 1
+  lo = lo.clip(0, knots.elements - 2)
+  hi = lo + 1
+  weight = (query - knots[lo]) / (knots[hi] - knots[lo])
+  table[lo] * (1.0 - weight) + table[hi] * weight
+end
+
+# And in Ruby, which is where this calculation usually lives.
+def interpolate_in_ruby (knots, table, query)
+  ks = knots.to_a
+  ts = table.to_a
+  query.to_a.map { |t|
+    lo = 0
+    hi = ks.size - 1
+    while hi - lo > 1
+      mid = (lo + hi) / 2
+      if ks[mid] > t then hi = mid else lo = mid end
+    end
+    weight = (t - ks[lo]) / (ks[lo + 1] - ks[lo])
+    ts[lo] * (1.0 - weight) + ts[lo + 1] * weight
+  }
+end
+
+here = interpolate(knots, table, query)
+there = interpolate_over_arrays(knots, table, query)
+
+puts format("%d queries against %d uneven samples", Q, N)
+puts format("  agrees with the whole-array route  %s", (here - there).abs.max == 0.0)
+puts format("  agrees with Ruby                   %s", here.to_a == interpolate_in_ruby(knots, table, query))
+puts format("  worst interpolation error          %.2e", (here - query.sin).abs.max)
+puts format("  and where the grid is coarsest     x = %.1f",
+            query[(here - query.sin).abs.max_addr])
+
+def timed (repeats = 5)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  repeats.times { yield }
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / repeats
+end
+
+compiled = timed { interpolate(knots, table, query) }
+searched = timed { knots.search_nearest(query) }
+whole = timed { interpolate_over_arrays(knots, table, query) }
+interpreted = timed(1) { interpolate_in_ruby(knots, table, query) }
+
+puts
+puts format("  one kernel, search and all      %7.1f ms", compiled * 1e3)
+puts format("  whole arrays, after the search  %7.1f ms   %.1fx",
+            (whole - searched) * 1e3, (whole - searched) / compiled)
+puts format("  whole arrays, with it           %7.1f ms   %.0fx",
+            whole * 1e3, whole / compiled)
+puts format("  Ruby, bisecting per query       %7.1f ms   %.0fx",
+            interpreted * 1e3, interpreted / compiled)
+
+# The middle line is the one about style: six passes over half a million
+# elements, and the arrays to hold them, against one pass that keeps `lo` in a
+# register.  The line below it is about the search, and belongs to
+# `search_nearest`'s contract rather than to arrays.
+puts
+puts format("  arrays of %d elements the whole-array route holds: 7", Q)
+puts format("  the kernel holds none, and bisects in %d comparisons",
+            Math.log2(N).ceil)

data/examples/applications/median_filter.rb

@@ -0,0 +1,153 @@
+# Despiking a series with a median, and where a cell keeps its scratch.
+#
+# A mean is ruined by one bad sample; a median is not, which is why a median
+# filter is what a record with spikes in it gets.  The window has to be
+# ordered to find its middle, and ordering a window is the thing an array
+# expression has no operation for: CArray can sort an array, but not the nine
+# cells around every cell, separately, a million times.
+#
+# So this is three spellings of one answer -- Ruby's, a kernel that sorts the
+# window in a workspace, and a kernel that finds the middle with comparisons
+# alone -- and they agree to the bit.  What separates them is where the cell's
+# scratch lives.  A workspace indexed by the cell is memory: a million rows of
+# nine, written and read on every comparison.  A local is a register.  It is
+# the same lesson every other kernel here quietly relies on, and this is where
+# it is worth a hundred times.
+#
+#   ruby examples/applications/median_filter.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+SAMPLES = 1_000_000
+WINDOW = 9
+HALF = WINDOW / 2
+
+# A smooth signal, some noise, and a spike every few hundred samples.
+random = CArray::Rng.new(seed: 20260913)
+noise = CArray.double(SAMPLES)
+noise.random!(rng: random)
+chance = CArray.double(SAMPLES)
+chance.random!(rng: random)
+signal = CArray.double(SAMPLES)
+clean = CArray.double(SAMPLES)
+CArray.jit_for(SAMPLES) { |i|
+  smooth = 10.0 * Math.sin(i / 5000.0) + 0.5 * (noise[i] - 0.5)
+  clean[i] = smooth
+  signal[i] = chance[i] < 0.002 ? smooth + 40.0 * (chance[i] * 500.0 - 0.5) : smooth
+}
+
+sorted_out = CArray.double(SAMPLES)
+network_out = CArray.double(SAMPLES)
+
+# One: the window copied into the cell's own row of a workspace and put in
+# order there.  Straightforward, and every comparison is a memory access.
+workspace = CArray.double(SAMPLES, WINDOW)
+
+def by_sorting (signal, out, workspace)
+  n = signal.elements
+  CArray.jit_for(HALF...(n - HALF)) { |i|
+    k = 0
+    while k < WINDOW
+      workspace[i, k] = signal[i - HALF + k]
+      k = k + 1
+    end
+    k = 1
+    while k < WINDOW
+      value = workspace[i, k]
+      j = k - 1
+      while j >= 0 && workspace[i, j] > value
+        workspace[i, j + 1] = workspace[i, j]
+        j = j - 1
+      end
+      workspace[i, j + 1] = value
+      k = k + 1
+    end
+    out[i] = workspace[i, HALF]
+  }
+end
+
+# Two: the median of nine by comparisons alone.  Order each group of three,
+# then take the largest of the three smallest, the middle of the middles and
+# the smallest of the largests, and the median of those three is the median
+# of the nine.  Nineteen comparisons, and nothing leaves a register.
+def by_network (signal, out)
+  n = signal.elements
+  CArray.jit_for(HALF...(n - HALF)) { |i|
+    a = signal[i - 4]; b = signal[i - 3]; c = signal[i - 2]
+    d = signal[i - 1]; e = signal[i];     f = signal[i + 1]
+    g = signal[i + 2]; h = signal[i + 3]; k = signal[i + 4]
+
+    lo = a < b ? a : b; hi = a < b ? b : a
+    mid = hi < c ? hi : c
+    m1 = lo > mid ? lo : mid
+    l1 = lo < c ? lo : c
+    h1 = hi > c ? hi : c
+
+    lo = d < e ? d : e; hi = d < e ? e : d
+    mid = hi < f ? hi : f
+    m2 = lo > mid ? lo : mid
+    l2 = lo < f ? lo : f
+    h2 = hi > f ? hi : f
+
+    lo = g < h ? g : h; hi = g < h ? h : g
+    mid = hi < k ? hi : k
+    m3 = lo > mid ? lo : mid
+    l3 = lo < k ? lo : k
+    h3 = hi > k ? hi : k
+
+    largest_small = l1 > l2 ? l1 : l2
+    largest_small = largest_small > l3 ? largest_small : l3
+    smallest_large = h1 < h2 ? h1 : h2
+    smallest_large = smallest_large < h3 ? smallest_large : h3
+
+    lo = m1 < m2 ? m1 : m2; hi = m1 < m2 ? m2 : m1
+    mid = hi < m3 ? hi : m3
+    middle_middle = lo > mid ? lo : mid
+
+    lo = largest_small < middle_middle ? largest_small : middle_middle
+    hi = largest_small < middle_middle ? middle_middle : largest_small
+    mid = hi < smallest_large ? hi : smallest_large
+    out[i] = lo > mid ? lo : mid
+  }
+end
+
+by_sorting(signal, sorted_out, workspace)
+by_network(signal, network_out)
+
+# And Ruby's, which is what this would otherwise be.
+def in_ruby (signal)
+  signal.to_a.each_cons(WINDOW).map { |window| window.sort[HALF] }
+end
+
+reference = in_ruby(signal)
+inner = HALF...(SAMPLES - HALF)
+puts format("%d samples, window of %d", SAMPLES, WINDOW)
+puts format("  the sorted kernel agrees with Ruby   %s",
+            inner.all? { |i| sorted_out[i] == reference[i - HALF] })
+puts format("  the network kernel agrees with Ruby  %s",
+            inner.all? { |i| network_out[i] == reference[i - HALF] })
+
+puts format("  %d spikes went in; the worst departure from the clean signal was %.2f, and is now %.2f",
+            chance.lt(0.002).count(1),
+            (signal[inner] - clean[inner]).abs.max,
+            (network_out[inner] - clean[inner]).abs.max)
+
+def timed (repeats = 3)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  repeats.times { yield }
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / repeats
+end
+
+sorting = timed { by_sorting(signal, sorted_out, workspace) }
+network = timed { by_network(signal, network_out) }
+interpreted = timed(1) { in_ruby(signal) }
+
+puts
+puts format("  Ruby, sorting each window            %7.0f ms", interpreted * 1e3)
+puts format("  kernel, sorting in a workspace       %7.0f ms   %.0fx",
+            sorting * 1e3, interpreted / sorting)
+puts format("  kernel, comparisons in registers     %7.0f ms   %.0fx",
+            network * 1e3, interpreted / network)
+puts format("  the workspace is %d x %d doubles, which is %.0f MB the other one never touches",
+            SAMPLES, WINDOW, SAMPLES * WINDOW * 8 / 1048576.0)

data/examples/applications/parcel_ascent.rb

@@ -0,0 +1,220 @@
+# Lifting a parcel up a sounding: CAPE, CIN, and where the cloud starts.
+#
+# Take the air at the ground and lift it.  It cools one way while it is dry
+# and another way once it has condensed, and the pressure where it switches
+# -- the lifting condensation level -- is not a constant: it is worked out
+# from that column's temperature and dew point.  Above it the parcel follows
+# a moist adiabat, which has no closed form and is integrated step by step,
+# each step starting from where the last one ended.  Whether the parcel is
+# warmer than the air around it decides whether that layer adds to the
+# convective available potential energy or to the inhibition, and the level
+# where the sign first turns positive -- the level of free convection -- is
+# itself discovered on the way up.
+#
+# There is no expression over whole arrays for any of that.  The state is
+# carried up the column, the equation changes partway at a level each column
+# picks for itself, and what a layer contributes depends on something that is
+# not known until the walk reaches it.  So a sounding is climbed in a loop,
+# one column at a time, and that is exactly what a kernel is.
+#
+# The physics is the textbook version: Bolton's LCL, a pseudoadiabat
+# integrated in pressure, and buoyancy from temperature rather than virtual
+# temperature.  Enough to be recognisable, not a substitute for a library.
+#
+#   ruby examples/applications/parcel_ascent.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+RD = 287.05                             # J/kg/K, dry air
+CPD = 1005.7                            # J/kg/K
+LV = 2.501e6                            # J/kg, vaporisation
+EPS = 0.622                             # molecular weight ratio
+KAPPA = 0.2854                          # Rd/cp
+
+LEVELS = 91                             # 1000 hPa to 100 hPa, every 10
+COLUMNS = 4_000                         # soundings to climb
+SUBSTEPS = 4                            # moist steps between two levels
+
+pressure = CArray.double(LEVELS).seq!(1000.0, -10.0)
+
+# Synthetic soundings: a lapse rate of 6.5 K/km over a surface that varies
+# from column to column, isothermal above the tropopause.
+random = CArray::Rng.new(seed: 20260913)
+surface = CArray.double(COLUMNS)
+surface.random!(rng: random)
+surface = surface * 12.0 + 22.0 + 273.15               # 22 to 34 degC
+spread = CArray.double(COLUMNS)
+spread.random!(rng: random)
+spread = spread * 14.0 + 2.0                           # dew point depression
+
+environment = CArray.double(COLUMNS, LEVELS)
+height = CArray.double(LEVELS)
+LEVELS.times { |k| height[k] = 44330.0 * (1.0 - (pressure[k] / 1013.25) ** 0.1903) }
+CArray.jit_for(COLUMNS, LEVELS) { |c, k|
+  lapsed = surface[c] - 0.0065 * height[k]
+  environment[c, k] = lapsed < 216.65 ? 216.65 : lapsed
+}
+dewpoint = environment[nil, 0] - spread
+
+cape = CArray.double(COLUMNS)
+cin = CArray.double(COLUMNS)
+lcl = CArray.double(COLUMNS)
+lfc = CArray.double(COLUMNS)
+el = CArray.double(COLUMNS)
+
+def climb (pressure, environment, dewpoint, cape, cin, lcl, lfc, el)
+  columns, levels = environment.dim
+  CArray.jit_for(columns) { |c|
+    base = pressure[0]
+    start = environment[c, 0]
+    dew = dewpoint[c] < start ? dewpoint[c] : start
+
+    # Bolton (1980): the temperature the parcel reaches when it saturates,
+    # and the pressure that goes with it along the dry adiabat.
+    saturating = 1.0 / (1.0 / (dew - 56.0) + Math.log(start / dew) / 800.0) + 56.0
+    condensation = base * Math.exp(Math.log(saturating / start) / KAPPA)
+    lcl[c] = condensation
+
+    parcel = start
+    at = base
+    positive = 0.0
+    pending = 0.0                       # negative area, until an LFC claims it
+    free = -1.0
+    equilibrium = -1.0
+
+    k = 1
+    while k < levels
+      target = pressure[k]
+      # Lift to this level, in at most two goes: dry as far as the
+      # condensation level, moist from there on.
+      while at > target + 1.0e-9
+        stop = at > condensation && condensation > target ? condensation : target
+        if at > condensation - 1.0e-9
+          parcel = start * Math.exp(KAPPA * Math.log(stop / base))
+          at = stop
+        else
+          step = (stop - at) / SUBSTEPS
+          n = 0
+          while n < SUBSTEPS
+            celsius = parcel - 273.15
+            saturation = 6.112 * Math.exp(17.67 * celsius / (celsius + 243.5))
+            mixing = EPS * saturation / (at - saturation)
+            numerator = RD * parcel + LV * mixing
+            denominator = CPD + (LV * LV * mixing * EPS) / (RD * parcel * parcel)
+            parcel = parcel + (numerator / denominator) * step / at
+            at = at + step
+            n = n + 1
+          end
+        end
+      end
+
+      # What this layer is worth.
+      excess = parcel - environment[c, k]
+      layer = RD * excess * Math.log(pressure[k - 1] / pressure[k])
+      if excess > 0.0
+        free = pressure[k] if free < 0.0
+        positive = positive + layer
+        equilibrium = pressure[k]
+      elsif free < 0.0
+        # Below the level of free convection, so this layer is what the
+        # parcel has to be pushed through: inhibition, not energy.
+        pending = pending + layer
+      end
+      k = k + 1
+    end
+
+    cape[c] = positive
+    cin[c] = free < 0.0 ? 0.0 : pending
+    lfc[c] = free
+    el[c] = equilibrium
+  }
+end
+
+climb(pressure, environment, dewpoint, cape, cin, lcl, lfc, el)
+
+puts format("%d soundings, %d levels each", COLUMNS, LEVELS)
+puts "   T    Td      LCL     LFC      EL     CAPE      CIN"
+[0, 1, 2, 3, 4].each do |c|
+  puts format("  %4.1f  %4.1f   %6.1f  %6.1f  %6.1f  %7.1f  %7.1f",
+              environment[c, 0] - 273.15, dewpoint[c] - 273.15,
+              lcl[c], lfc[c], el[c], cape[c], cin[c])
+end
+
+# What has to hold if the climb was a climb.
+reached = lfc.gt(0.0)
+puts
+puts format("  %d of %d columns reached a level of free convection", reached.count(1), COLUMNS)
+puts format("  the LFC is never below the LCL   %s",
+            (lfc[reached] - lcl[reached]).max <= 0.0)
+puts format("  the EL is never below the LFC    %s",
+            (el[reached] - lfc[reached]).max <= 0.0)
+puts format("  CAPE is zero exactly where there is no LFC  %s",
+            cape[reached.not].max == 0.0)
+puts format("  strongest column: CAPE %.0f J/kg with CIN %.0f J/kg",
+            cape.max, cin[cape.max_addr])
+
+# The same climb in Ruby.
+def climb_in_ruby (pressure, environment, dewpoint)
+  columns, levels = environment.dim
+  levels_a = pressure.to_a
+  cape = Array.new(columns, 0.0)
+  columns.times do |c|
+    base = levels_a[0]
+    start = environment[c, 0]
+    dew = [dewpoint[c], start].min
+    saturating = 1.0 / (1.0 / (dew - 56.0) + Math.log(start / dew) / 800.0) + 56.0
+    condensation = base * Math.exp(Math.log(saturating / start) / KAPPA)
+    parcel = start
+    at = base
+    positive = 0.0
+    free = -1.0
+    (1...levels).each do |k|
+      target = levels_a[k]
+      while at > target + 1.0e-9
+        stop = at > condensation && condensation > target ? condensation : target
+        if at > condensation - 1.0e-9
+          parcel = start * Math.exp(KAPPA * Math.log(stop / base))
+          at = stop
+        else
+          step = (stop - at) / SUBSTEPS
+          SUBSTEPS.times do
+            celsius = parcel - 273.15
+            saturation = 6.112 * Math.exp(17.67 * celsius / (celsius + 243.5))
+            mixing = EPS * saturation / (at - saturation)
+            numerator = RD * parcel + LV * mixing
+            denominator = CPD + (LV * LV * mixing * EPS) / (RD * parcel * parcel)
+            parcel += (numerator / denominator) * step / at
+            at += step
+          end
+        end
+      end
+      excess = parcel - environment[c, k]
+      if excess > 0.0
+        free = levels_a[k] if free < 0.0
+        positive += RD * excess * Math.log(levels_a[k - 1] / levels_a[k])
+      end
+    end
+    cape[c] = positive
+  end
+  cape
+end
+
+in_ruby = climb_in_ruby(pressure, environment, dewpoint)
+agree = (0...COLUMNS).all? { |c| (cape[c] - in_ruby[c]).abs < 1.0e-9 }
+puts format("  agrees with the same climb in Ruby  %s", agree)
+
+def timed (repeats = 3)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  repeats.times { yield }
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / repeats
+end
+
+compiled = timed { climb(pressure, environment, dewpoint, cape, cin, lcl, lfc, el) }
+interpreted = timed(1) { climb_in_ruby(pressure, environment, dewpoint) }
+
+puts
+puts format("  %6.1f ms compiled, %6.0f ms in Ruby (%.0fx)",
+            compiled * 1e3, interpreted * 1e3, interpreted / compiled)
+puts format("  each column: %d levels, a condensation level of its own, and %d moist steps above it",
+            LEVELS, SUBSTEPS)

data/examples/applications/point_in_polygon.rb

@@ -0,0 +1,111 @@
+# Which of a million points are inside a polygon.
+#
+# The test is the old one: send a ray out from the point and count the edges
+# it crosses; an odd count means inside.  Counting is a loop over the edges,
+# and the count is one integer that belongs to the point.
+#
+# An array expression cannot keep that integer.  It can compare a point
+# against an edge -- but the comparison has to be made for every point and
+# every edge, and holding those answers is an array of points by edges.  With
+# a million points and two hundred edges that is a temporary of 1.5 GB, built
+# so that it can immediately be summed away.  The kernel keeps the count in a
+# register and the polygon is read where it lies.
+#
+#   ruby examples/applications/point_in_polygon.rb
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __dir__))
+require "carray/jit"
+
+EDGES = 200
+POINTS = 1_000_000
+
+# A lobed blob, closed, going round once.
+corner_x = CArray.double(EDGES)
+corner_y = CArray.double(EDGES)
+CArray.jit_for(EDGES) { |k|
+  angle = 2.0 * Math::PI * k / EDGES
+  radius = 1.0 + 0.35 * Math.sin(7.0 * angle) + 0.15 * Math.cos(3.0 * angle)
+  corner_x[k] = radius * Math.cos(angle)
+  corner_y[k] = radius * Math.sin(angle)
+}
+
+random = CArray::Rng.new(seed: 20260913)
+point_x = CArray.double(POINTS)
+point_x.random!(rng: random)
+point_x = point_x * 3.2 - 1.6
+point_y = CArray.double(POINTS)
+point_y.random!(rng: random)
+point_y = point_y * 3.2 - 1.6
+
+inside = CArray.int8(POINTS)
+
+def classify (point_x, point_y, corner_x, corner_y, inside)
+  edges = corner_x.elements
+  CArray.jit_for(point_x.elements) { |i|
+    x = point_x[i]
+    y = point_y[i]
+    crossings = 0
+    k = 0
+    while k < edges
+      j = k == 0 ? edges - 1 : k - 1
+      this_y = corner_y[k]
+      last_y = corner_y[j]
+      # The edge has to straddle the ray for the crossing to count, and the
+      # test is written so that a vertex exactly on the ray counts once.
+      if (this_y > y) != (last_y > y)
+        cut = corner_x[j] + (y - last_y) * (corner_x[k] - corner_x[j]) / (this_y - last_y)
+        crossings = crossings + 1 if x < cut
+      end
+      k = k + 1
+    end
+    inside[i] = crossings % 2
+  }
+end
+
+classify(point_x, point_y, corner_x, corner_y, inside)
+
+puts format("%d points against a polygon of %d edges", POINTS, EDGES)
+puts format("  inside  %d  (%.1f%% of the square they were drawn in)",
+            inside.sum, 100.0 * inside.sum / POINTS)
+
+# The same test in Ruby, over as many points as is polite to wait for.
+SAMPLE = 20_000
+
+def classify_in_ruby (x, y, corner_x, corner_y)
+  edges = corner_x.elements
+  odd = false
+  j = edges - 1
+  (0...edges).each do |k|
+    if (corner_y[k] > y) != (corner_y[j] > y)
+      cut = corner_x[j] + (y - corner_y[j]) *
+            (corner_x[k] - corner_x[j]) / (corner_y[k] - corner_y[j])
+      odd = !odd if x < cut
+    end
+    j = k
+  end
+  odd ? 1 : 0
+end
+
+def timed (repeats = 3)
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  repeats.times { yield }
+  (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / repeats
+end
+
+agree = (0...SAMPLE).all? { |i|
+  inside[i] == classify_in_ruby(point_x[i], point_y[i], corner_x, corner_y)
+}
+puts format("  agrees with Ruby over the first %d  %s", SAMPLE, agree)
+
+compiled = timed { classify(point_x, point_y, corner_x, corner_y, inside) }
+interpreted = timed(1) {
+  SAMPLE.times { |i| classify_in_ruby(point_x[i], point_y[i], corner_x, corner_y) }
+}
+
+puts
+puts format("  %6.0f ms here for %d points", compiled * 1e3, POINTS)
+puts format("  %6.0f ms in Ruby for %d, so about %.0f s for the million",
+            interpreted * 1e3, SAMPLE, interpreted * POINTS / SAMPLE)
+puts format("  the array route would hold %d x %d doubles on the way -- %.1f GB,",
+            POINTS, EDGES, POINTS.to_f * EDGES * 8 / (1 << 30))
+puts        "  built only to be summed away; this one holds one integer, in a register"